예제 #1
0
        /// <summary>
        /// Main method to write the line of SQL to the text file
        /// </summary>
        /// <param name="data"></param>
        protected override void RegisterExecutionComplete(ProfilerExecData data)
        {
            base.RegisterExecutionComplete(data);

            StringBuilder sb         = new StringBuilder();
            string        baseformat = "{0:0000000}";

            string sql = data.SQL.Replace('\n', ' ').Replace('\r', ' ').Replace('\t', ' ');

            string dur = string.Format("{0:0.0000}", data.Duration.TotalMilliseconds);

            if (dur.Length < 12)
            {
                dur = dur.PadLeft(12);
            }


            sb.AppendFormat(baseformat, data.ExecutionID);
            sb.Append("\t");
            sb.Append(dur);
            sb.Append("\t");
            sb.Append(sql);

            if (data.Parameters != null && data.Parameters.Length > 0)
            {
                foreach (object p in data.Parameters)
                {
                    sb.Append('\t');
                    if (null == p || p is DBNull)
                    {
                        sb.Append("[NULL]");
                    }
                    else
                    {
                        sb.Append(p);
                    }
                }
            }
            sb.Append("\r\n");

            string path = this.FilePath;

            path = path.Replace("[Date]", DateTime.Today.ToString("yyyy_MM_dd"))
                   .Replace("[Name]", this.ProfilerName)
                   .Replace("[Connection]", data.Connection);

            lock (_filelock)
            {
                if (!System.IO.File.Exists(path))
                {
                    System.IO.File.AppendAllText(path, HeaderString);
                }
                System.IO.File.AppendAllText(path, sb.ToString());
            }
        }
 public bool TryGetSummary(ProfilerExecData data, out ProfilerExecSummary summary)
 {
     if (this.Count == 0)
     {
         summary = null;
         return(false);
     }
     else
     {
         string key = GetKey(data.Connection, data.SQL);
         return(this.Dictionary.TryGetValue(key, out summary));
     }
 }
예제 #3
0
        //
        // public methods
        //


        #region public IDBProfileExecData BeginExecution(string connectionName, string sql, params object[] parameters)

        /// <summary>
        /// Registers the start of an execution and returns the ProfileData instance which
        /// encapsulates the required data and identifies it.
        /// </summary>
        /// <param name="connectionName"></param>
        /// <param name="sql"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        public IDBProfileExecData BeginExecution(string connectionName, string sql, params object[] parameters)
        {
            int id = _nextid++;//should place this in a lock, but the impact of is greater than the chance of clash

            if (_nextid == int.MaxValue)
            {
                _nextid = 0;
            }
            ProfilerExecData data = new ProfilerExecData(connectionName, id, sql, _running.Elapsed);

            data.Parameters = parameters;
            this.RegisterBeginExecution(id, data);
            return(data);
        }
예제 #4
0
        //
        // support methods
        //

        #region private void UpdateExecutionSummary(ProfileData data)

        /// <summary>
        /// Updates a ProfileDataSummary by calling RegisterExecution
        /// </summary>
        /// <param name="data"></param>
        private void UpdateExecutionSummary(ProfilerExecData data)
        {
            ProfilerExecSummary summary;

            if (!_summaries.TryGetSummary(data, out summary))
            {
                lock (_summaryLock)
                {
                    if (!_summaries.TryGetSummary(data, out summary))
                    {
                        summary = new ProfilerExecSummary(data.Connection, data.SQL);
                        _summaries.Add(summary);
                    }
                }
            }
            summary.RegisterExecution(data);
        }
예제 #5
0
        //
        // implementation methods
        //

        #region protected override void RegisterExecutionComplete(ProfilerExecData data)

        /// <summary>
        /// overrides the base method to write a formatted string to the console.
        /// </summary>
        /// <param name="data"></param>
        protected override void RegisterExecutionComplete(ProfilerExecData data)
        {
            int    index         = 0;
            int    sqllinelength = 70;
            string front         = string.Format("{0:000000}:{1} -> ", data.ExecutionID, data.Connection);

            string        full    = data.SQL.Replace('\n', ' ').Replace("\r", "").Replace("\t", "");
            string        padleft = "".PadLeft(front.Length);//format length of execution id and the colon and space.
            StringBuilder sb      = new StringBuilder(front);

            while (index < full.Length)
            {
                if (index > 0)
                {
                    sb.Append(padleft);
                    sb.Append("...");
                }

                if (index + sqllinelength > full.Length)
                {
                    sb.Append(full, index, full.Length - index);
                }
                else
                {
                    sb.Append(full, index, sqllinelength);
                    sb.Append("...");
                }

                if (index == 0)
                {
                    sb.Append("   Duration:");
                    sb.Append(data.Duration);

                    //trim the line length to 3 less for the elipsis
                    index         += 3;
                    sqllinelength -= 3;
                }

                sb.Append("\r\n");
                index += sqllinelength;
            }

            Console.Write(sb.ToString());
            base.RegisterExecutionComplete(data);
        }
예제 #6
0
        public virtual void RegisterExecution(ProfilerExecData dataexec)
        {
            if (null == dataexec)
            {
                throw new ArgumentNullException("dataexec");
            }
            else if (!string.Equals(dataexec.SQL, this.SQL, StringComparison.OrdinalIgnoreCase))
            {
                throw new ArgumentOutOfRangeException("dataexec", "The SQL strings do not match");
            }


            long val = dataexec.Duration.Ticks;

            //update _all list
            if (_exec > 0)
            {
                //second run so init _all list and add the first
                if (_exec == 1)
                {
                    _all = new List <long>();
                    _all.Add(_dur);
                }
                _all.Add(val);
            }

            //update total + mean
            _dur  += val;
            _exec += 1;

            //update min max
            if (_exec == 1)
            {
                _min = val;
                _max = val;
            }
            else
            {
                _max = Math.Max(_max, val);
                _min = Math.Min(_min, val);
            }
        }
예제 #7
0
        /// <summary>
        /// Registers the end of the execution for a specific execution data - this is the ProfileData returned from the BeginExecution method
        /// </summary>
        /// <param name="data">The profile data returned from a BeginExecution method</param>
        public void EndExecution(IDBProfileExecData data)
        {
            if (null == data)
            {
                throw new ArgumentNullException("data");
            }
            if (!(data is ProfilerExecData))
            {
                throw new InvalidCastException("data");
            }

            ProfilerExecData execdata = data as ProfilerExecData;

            execdata.Ended = _running.Elapsed;
            this.RegisterExecutionComplete(execdata);

            if (this._collect)
            {
                this.UpdateExecutionSummary(execdata);
            }
        }
예제 #8
0
 public bool Equals(ProfilerExecData data)
 {
     return(this.ExecutionID == data.ExecutionID && this.Connection == data.Connection);
 }
예제 #9
0
 /// <summary>
 /// Inheritors should override this method if they wish to
 /// record the completion of a Database execution. Default implementation does nothing
 /// </summary>
 /// <param name="data">The data associated with the Execution</param>
 protected virtual void RegisterExecutionComplete(ProfilerExecData data)
 {
     //Inheritors should override, or do nothing
 }
예제 #10
0
        //
        // protected virtual methods that should be overriden as required.
        //

        #region protected virtual void RegisterBeginExecution(int execid, ProfileData data)

        /// <summary>
        /// Inheritors should override this method if they wish to
        /// record the commencement of an DBExecution. Default implementation does nothing
        /// </summary>
        /// <param name="execid"></param>
        /// <param name="data"></param>
        protected virtual void RegisterBeginExecution(int execid, ProfilerExecData data)
        {
            //Empty method that can be overwritten
        }