tsql

KILL spid (WITH STATUSONLY)
This article talks about how to stop or terminate a process that is running. Stopping a process shouldn't be the first step when troubleshooting as it can possibly make the situation worse. However, it can sometimes be helpful in clearing blocking chains or other performance issues.

In order to know what to stop, you will need to know what processes or queries are running. There are a variety of ways to see all of the processes or queries running right now, including the following:
- Microsoft built in tools - sp_who and sp_who2
- Adam Mechanic's tool - Who is Active (Click here to download it)
- Hand made query using the sys.dm_exec_requests and/or the sys.dm_exec_sessions tables
KILL

Once you know the session ID (spid) of the query or process you want to stop, you can do so by using the KILL command. The kill command is pretty straight forward. The syntax is simply: KILL spid (replace the text "spid" with the number of the process desired to be stopped)

A word of caution here, there are times when it is best not to kill a session. One example is if a process has been running for a while and using multiple threads, when it is killed, the rollback operation will only be single threaded. Therefore, the rollback could take much longer than letting the process finish on its own. All of the same performance issues and/or blocking will still continue, so it actually could things worse, not better.

Some processes are not able to be stopped: per Microsoft, "System processes and processes running an extended stored procedure cannot be terminated."

UNIT OF WORK ID

The kill command can also be used to stop or terminate orphaned distributed transactions. The GUID value that is the Unit of Work ID (UOW ID) can be found in either the error log, the MS DTC monitor, or the sys.dm_tran_locks dmv.

The syntax is simply: KILL uowid

WITH STATUSONLY

While I knew about the kill command, I wasnt aware that you are able to check the status of the rollback process with the WITH STATUSONLY option until semi-recently.

The syntax is simple KILL spid WITH STATUSONLY - or - KILL uowid WITH STATUSONLY

For processes that are in the middle of being rolled back, this will show the status of the rollback. This option doesn't "do" anything, it just shows the progress. Keep in mind that as with other Microsoft provided durations, it isn't an exact number. This is more of a ball park figure that might be semi-right, but may also be a bit off from the actual time.

If you run this option on a spid that isnt part of a rollback, it wont hurt anything. You will just see an error returned indicating a rollback isnt in progress.

Its funny, but whenever I have to kill a process (which is thankfully rare), I cant help but do a bad-guy cackle in my head... lol!
T-SQL and XML
I was wary of XML when I first heard about it - mostly because I was still trying to wrap my head around other stuff that I was learning. Therefore, I didnt learn much about it at first. Then, I needed to pass multiple values to a stored procedure and looked into it. I quickly fell in love!! There are many posts about using XML within T-SQL. I am posting one so that I can search on my own blog for this when I need it - I dont seem to keep it in my head long enough to use it the next time I need it. :)

I am going to use examples from my alerter system, that is where I am using it as I am writing this article - so 2 birds with 1 stone - cant beat that! By the way, I will format the SQL code better - it looks weird being all gray!
T-SQL Random Number Generator
I recently needed to generate a random number. I know using rand() was the way to go, but it wsnt giving me the formatting I needed. I went online (lazy, cause I know I could format a stupid number) and found an amazing little script that I expanded upon. It gives you a min and max range which was perfect!

Here is the code and a link to the site I got it from (giving props to Michelle at sqlfool.com for it!)
```
Declare @maxRandomValue tinyint = 100
	, @minRandomValue tinyint = 0;
 
Select Cast(((@maxRandomValue + 1) - @minRandomValue) 
	* Rand() + @minRandomValue As tinyint) As 'randomNumber';
```
http://sqlfool.com/2009/06/random-number-generator-in-tsql/
Using Transactions
I wanted to jot some notes down about using transactions and @@trancount - mostly, I personally like checking for if I should begin a transaction or not at the beginning of stored procedures. I know this comes from me being a software developer and thinking the database guy/gal handles all that, and then learning more about the database side of things and realizing database coding isnt always reviewed that closely by a DBA. So, it came time for me to learn. Now that I switched jobs, I dont have all the code blocks to copy/paste - so this blog post will help with that! :)

Lets start with the basics:

A transaction is a sequence of operations performed in it's own "bubble" from other processes and/or transactions occuring. Once a transaction is completed, the effects are permanent in the database.

Now, that is a simple explanation, as with everything, there are many things that go into it - such as how transactions affect each other because the data that is modified in 1 transaction is the same data needed for another transaction, so the "bubble" a transaction is in isnt completely isolated - or how if a transaction is rolled back, there is no permanent effect because nothing was done, etc. I am going to talk about some of the ways of starting, monitoring, and ending a transaction, as well as nested transactions, and possibly uncommitable transactions.

To start a transaction, the syntax is BEGIN TRANSACTION (or BEGIN TRAN). No matter what, this is pretty much straight forward. To end a transaction, you would either use COMMIT TRANSACTION, or ROLLBACK TRANSACTION, depending on if you want to make the changes you made, or not make the desired changes, respectively. That, in and of itself, is all you need to start utilizing transactions now - but I will keep going with more juicy info. :)

tsql

Menu

Blog

Contact Me