SQL Server

Sometimes we wish to know what locks are being held by the transaction. Also it would be great to know what SPID owns the transaction, on which objects the locks are being held, what SQL statement caused the locks, etc...

With the introduction of DMV's in SQL Server 2005 getting this information is quite easy with this query:

SELECT  L.request_session_id AS SPID, 
        DB_NAME(L.resource_database_id) AS DatabaseName,
        O.Name AS LockedObjectName, 
        P.object_id AS LockedObjectId, 
        L.resource_type AS LockedResource, 
        L.request_mode AS LockType,
        ST.text AS SqlStatementText,        
        ES.login_name AS LoginName,
        ES.host_name AS HostName,
        TST.is_user_transaction as IsUserTransaction,
        AT.name as TransactionName,
        CN.auth_scheme as AuthenticationMethod
FROM    sys.dm_tran_locks L
        JOIN sys.partitions P ON P.hobt_id = L.resource_associated_entity_id
        JOIN sys.objects O ON O.object_id = P.object_id
        JOIN sys.dm_exec_sessions ES ON ES.session_id = L.request_session_id
        JOIN sys.dm_tran_session_transactions TST ON ES.session_id = TST.session_id
        JOIN sys.dm_tran_active_transactions AT ON TST.transaction_id = AT.transaction_id
        JOIN sys.dm_exec_connections CN ON CN.session_id = ES.session_id
        CROSS APPLY sys.dm_exec_sql_text(CN.most_recent_sql_handle) AS ST
WHERE   resource_database_id = db_id()
ORDER BY L.request_session_id

Let's look at it one DMV at a time from top to bottom:

sys.dm_tran_locks:

Shows us all locks held on all resources for all transaction. We start from this view since we want to get information about locked resources.

sys.partitions:

Contains information about partitions in the database. We can join it to the sys.dm_tran_locks on the hobt_id only for resource_type values 'HOBT', 'Page', 'RID' and 'Key'. With this join we get the object_id of our locked table.

sys.objects:

Contains data for all schema scoped database objects. We join it to sys.partitions to get the Name of the locked object which is usually a table name.

sys.dm_exec_sessions:

Shows data about all active sessions on SQL server. We join it to sys.dm_tran_locks to get user login information for each held lock.

sys.dm_tran_session_transactions:

Shows data for all transactions for a session. By joining in to sys.dm_exec_sessions we get a link to all active transactions in the session.

sys.dm_tran_active_transactions:

Shows data for all active transactions in SQL Server. By joining it to sys.dm_tran_session_transactions we only get information for the session we want.

sys.dm_exec_connections:

Shows data for all connections in SQL Server. By joining it to sys.dm_exec_sessions we get connection info for our session.

sys.dm_exec_sql_text:

Returns SQL statement that is associated with the SQL handle input parameter. By cross applying it to the sys.dm_exec_connections we get the last executed statement for the connection, which in our case is the statement that is holding locks.

By applying the filter in the where clause you get the answers to questions like:

- What SQL Statement is causing the lock?

- Which user has executed the SQL statement that's holding the locks?

- What objects/tables are being locked?

- What kinds of locks are being held and on which pages, keys, RID's?

- etc...

How SQL Server short-circuits WHERE condition evaluation

Mladen Prajdić — Mon, 25 Feb 2008 09:54:24 GMT

It does when it feels like it, but not in the way you immediately think of.

A few days ago Jeff posted about short-circuiting wondering how it works and since I've played with this a long while ago I thought I'd share my results. Hopefully it will make it clearer how SQL Server behaves when evaluating conditions in its WHERE clause. So let's see how it's done in greater detail.

First we must create our test table with some sample data which will be defined like this:

IF OBJECT_ID('t1') IS NOT NULL
     DROP TABLE t1

CREATE TABLE t1(id INT PRIMARY KEY, val VARCHAR(10))
INSERT INTO t1
SELECT 1, '19000101' UNION ALL 
SELECT 2, 'val 2' UNION ALL 
SELECT 3, '20080303'

Now let's play a bit. :)

AND Conditions

Run this statement:

SELECT * FROM t1 
WHERE  id / 0 = 1
       AND id = 2
       AND CONVERT(DATETIME, val) > GETDATE()

You'll get this error:

Msg 241, Level 16, State 1, Line 10
Conversion failed when converting datetime from character string.

The execution plan shows us how SQL Server parameterizes our select statement:

SELECT * FROM [t1] WHERE [id]/@1=@2 AND [id]=@3 AND CONVERT([datetime],[val],0) > getdate()

The most obvious condition to fail is of course the divide by zero. You'd think it would be the first to evaluate since it's obviously an illegal call and everything else would be discarded. However because of the statement parameterization this doesn't happen because at the condition evaluation time the values 0 and 1 aren't known. For SQL Server they are still valid parameters whose condition cost must be evaluated. Going back to our error message we can see that the only row with an invalid date is the one where id = 2. This tells us that query processor first looked up the row by id, then applied the datetime conversion. Thus we get our order. Following query only strengthens our deduction since now we get the "Divide by zero error encountered" because the date successfully converted.

SELECT * FROM t1 
WHERE  id / 0 = 1
       AND id = 3
       AND CONVERT(DATETIME, val) > GETDATE()

This example shows us how SQL Server short-circuits conditions based on some internal threshold that measures condition importance and their evaluation order. There's nothing we can do about this and the order of condition evaluation when actually reading data is unknown to us.

OR Conditions

Run this statement:

SELECT * FROM t1 
WHERE  id = 3
       OR id / 0 = 1

Here it is a whole different story than above with only AND conditions. Here you immediately see the error "Divide by zero error encountered". If you take a closer look you'll see that we never get to the execution plan phase. Why does this differ so much from the AND conditions? Because OR's immediately mean Table/Index scan. Therefore no parameterization is done and at the query evaluation time all of the values are known. This is when the divide by zero is caught before the execution plan is even built or taken from cache and our query fails. It doesn't matter that our first condition is already true.

Literal Conditions

Run these statements:

SELECT 1 WHERE (1 = 1) OR (1 / 0 = 0)
SELECT 1 WHERE (1 = 0) OR (1 / 0 = 0)

We see that with literal conditions the short circuiting is being done on 1=1 and 1=0 and the 1 / 0 isn't evaluated at all, but this is not to be mistaken to work identically with real data as is shown above.

CASE Statement Conditions

Run these 2 statements:

SELECT * FROM t1 
WHERE  CASE
           WHEN ISDATE(val) = 0 THEN 0
           WHEN CONVERT(DATETIME, val) > GETDATE() THEN 1            
           ELSE 0
       END = 1

SELECT * FROM t1 
WHERE  CASE
           WHEN CONVERT(DATETIME, val) > GETDATE() THEN 1           
           WHEN ISDATE(val) = 0 THEN 0           
           ELSE 0
       END = 1

These 2 statements nicely illustrate that the order of condition evaluation in the CASE statement is always from first to last. The first statement will return one row since the second rows with invalid date will be filtered out by the ISDATE() function, while in the second statement it won't be filtered out and it will throw an error. This is of course quite logical because a CASE statement is simply a big if... else if... else... statement written differently.

If C++/C#/VB has short-circuiting why can't SQL Server have it?

To truly answer this let's take a look at how both work with conditions. C++/C#/VB all have short circuiting defined in the language specifications to speed up code execution. Why bother evaluating N OR conditions when the first one is already true or M AND conditions when the first one is already false.

We as developers have to be aware that SQL Server works differently. It is a cost based system. To get the optimal execution plan for our query the query processor has to evaluate every where condition and assign it a cost. These costs are then evaluated as a whole to form a threshold that must be lower than the defined threshold SQL Server has for a good plan. If the cost is lower than the defined threshold the plan is used, if not the whole process is repeated again with a different mix of condition costs. Cost here is either a scan or a seek or a merge join or a hash join etc... Because of this the short-circuiting as is available in C++/C#/VB simply isn't possible. You might think that forcing use of index on a column counts as short circuiting but it doesn't. It only forces the use of that index and with that shortens the list of possible execution plans. The system is still cost based.

As a developer you must be aware that SQL Server does not do short-circuiting like it is done in other programming languages and there's nothing you can do to force it to.

Integrating Profiler and PerfMon Log Files

Mladen Prajdić — Fri, 08 Feb 2008 13:49:34 GMT

I've written an article here on SQL Team about Integrating Profiler and PerfMon Log Files.

Troubleshooting SQL Server requires the use of both PerfMon (Performance/System Monitor) and SQL Trace files created by SQL Profiler or directly by SQL Server trace. Analysis of the gathered data is much easier if you can correlate your trace file with the PerfMon counters. In this article I'll show how to create a PerfMon counters log file and SQL Profiler Trace file, how to read them both and how to correlate the two files in SQL Profiler.

Integrating Profiler and PerfMon Log Files

Back to Basics: Count, Count, Count, Sum or how to Count

Mladen Prajdić — Mon, 04 Feb 2008 16:24:04 GMT

Probably everyone is familiar with the Count(*) function in SQL Server.

But there seems to be a great deal of confusion amongst youngsters (SQL wise) about how all its possible options work.

Let us banish the confusion back to the dark realms where in belongs to:

DECLARE @t TABLE (val INT)
INSERT INTO @t
SELECT 1 UNION ALL
SELECT 1 UNION ALL
SELECT NULL UNION ALL
SELECT NULL UNION ALL
SELECT 4 UNION ALL
SELECT 4 UNION ALL
SELECT 5

SELECT COUNT(*) AS CountAll, -- counts all rows
       COUNT(val) AS CountAllNoNull, -- counts rows that don't contain NULL
       COUNT(DISTINCT val) AS CountDistinctNoNulls, -- counts the number of distinct values
       COUNT(*) - COUNT(val) AS CountOfNullValues -- count of NULL values in the column 
FROM   @t

There are 3 ways in which Count() works:

COUNT(*) - Counts all rows in the table

COUNT(ColumnName) - Counts all rows in the table that don't contain NULL in the specified column

COUNT(DISTINCT ColumnName) - Counts all DISTINCT rows in the table that don't contain NULL in the specified column

We can see that with the use of these 3 options we can get easily get the number of NULL values in the column.

So where does the Sum come in here? Sum can be used to get a count of practically anything with just one table scan.

Let's illustrate:

SELECT SUM(CASE WHEN val < 3 THEN 1 ELSE 0 END) AS LessThanTree,
       SUM(CASE WHEN val > 4 THEN 1 ELSE 0 END) AS MoreThanFour
       -- SUM(CASE WHEN <Any condition you can think of> THEN 1 ELSE 0 END) AS Col1
FROM   @t

To follow the primary school logic here:

If something fits the condition return 1 else return 0. The sum of all 1's returns the number of items that satisfy the desired condition.

And the condition is limited only by your business requirement.

You see there's no need to write nested select statements similar to this:

SELECT (SELECT COUNT(*) FROM MyTable WHERE <someCondition1>) AS cnt1, 
       (SELECT COUNT(*) FROM MyTable WHERE <someCondition1>) AS cnt2

Jeff has also has a good post about translating these kind of queries to case statements here.

And this might even provide a nice interview question...

Introduction to locking in SQL Server 2005

Mladen Prajdić — Wed, 12 Dec 2007 19:36:13 GMT

I've written an article here on SQL Team about locking in SQL Server.

It's an introductory article that shows lock modes, lock granularity and lock compatibility matrix

and it will be followed by a few more advanced ones on the topic of locking.

Part 1: Introduction to locking in SQL Server 2005

SQL Server 2005: Synonyms in T-SQL (analogous to Aliases in .Net)

Mladen Prajdić — Mon, 26 Nov 2007 20:37:26 GMT

If you're a .Net developer aliases should be very familiar to you.

if they're not here is a reminder:

using MyAlias = This.Is.My.Full.Namespace.MyClass;
MyAlias m = new MyAlias(); // MyAlias is of course of type MyClass

Well it seems SQL Server 2005 added a similar functionality to T-SQL. It's called Synonyms.

You can use them in all CRUD operations as well as in sub-selects and dynamic SQL

What's interesting is that synonyms are evaluated at run time and the binding between the synonym and an object is by name only.

This means that you can drop the object referenced by the synonym at any time, but you'll get an error only at run-time.

They are useful because they provide a level of abstraction in your app, since you can change the name or even a location of the object

referenced by the synonym.

And not to mention having less to type as seen in this example:

USE tempdb;
GO
-- Create a synonym for the Product table in AdventureWorks.
CREATE SYNONYM MyProduct
FOR AdventureWorks.Production.Product;
GO

-- Query the Product table by using the synonym.
USE tempdb;
GO
SELECT ProductID, Name 
FROM MyProduct
WHERE ProductID < 5;
GO

These database objects can be referenced by a synonym:

- SQL stored procedures, scalar, table-valued and inline-tabled-valued functions

- Views

- Local and global temporary tables

- Replication-filter and extended stored procedures

- CLR stored procedures, table-valued, scalar and aggregate functions

Don't know in how widespread use this will be but it's a nice feature that can come in handy.

Free SQL Server tools that might make your life a little easier

Mladen Prajdić — Tue, 20 Nov 2007 17:31:57 GMT

Update: New Stuff from the latest update will be in RED.

This list will grow as I find new tools. So if you know of some not on this list do post them in the comments.

SQL Server Management Studio Add-in's

SSMS Tools Pack - an add-in with lots of IDE options (Query Execution history, regions, debug sections, CRUD stored procedures creation, new query templates, running custom scripts from Object explorer's context menu) for SQL Server Management Studio and SQL Server Management Studio Express

Data Scripter - generates insert statements for a table

Create Database Snapshot - simple GUI for creating a database snapshot

Sort SQL Project Files - sorts SQL project files

The Black Art of Writing a SQL Server Management Studio 2005 Add-In - a how-to article and a Search DB Objects add-in with code

How to create SSMS Add-in - an article that describes how to create add-ins without any source code

Administration

SQL Internals Viewer - a tool for looking into the SQL Server storage engine and seeing how data is physically allocated, organised and stored.

Microsoft SQL Server 2000/2005 Management Pack - monitors the availability and performance of SQL Server 2000 and 2005 and can issue alerts for configuration problems.

Performance Analysis of Logs (PAL) Tool - tool that reads in a performance monitor counter log (any known format) and analyzes it using complex, but known thresholds (provided).

Microsoft Baseline Security Analyzer - helps small- and medium-sized businesses determine their security state in accordance with Microsoft security recommendations and offers specific remediation guidance

RML Utilities for SQL Server (x86) and (x64) - tools to help database administrators manage the performance of Microsoft SQL Server: Overview

SQLDumper.exe - comes with SQL Server. Installed at ..\Microsoft SQL Server\90\Shared\SQLDumper.exe. Generates a dump file on demand for any Microsoft Windows application.

SQL Server 2005 Partition Management - helps in data loading and extraction from partitions

SQLdiag Utility - a general purpose diagnostics collection utility that can be run as a console application or as a service (comes with SQL Server)

SQL Nexus - analyzes SQLDIAG captures

PSSDiag Utility - a general purpose diagnostic collection utility that Microsoft Product Support Services uses to collect various logs and data files

SQL Recon - performs active and passive scans of your network in order to identify all of the SQL Server/MSDE installations in your enterprise

SQL Internals Viewer - looks into the SQL Server storage engine seeing how data is physically allocated, organized and stored.

SQL Server 2005 Express Profiler - a free SQL Profiler for SQL Express

Log Parser 2.2 - provides query access to log files, XML files and CSV files, the Event Log, the Registry, the file system, and Active Directory

Microsoft SQL Server Management Studio Express - apparently a lot of people don't know this exists. Stripped down version of SSMS

SQL Server 2005 System Views Map - a nice map of all the DMV's and links between them

SQL Server Web Data Administrator - admin your SQL Server over the web

SQL Server Express Utility - simple interaction with SQL Server

TableDiff.exe - utility that compares 2 tables for differences in data and schema for SQL Server 2000 and 2005

DMVStats - collects, analyzes and reports on SQL Server 2005 DMV performance data

Best practices, analysis, health and performance

SQL Server 2005 Assessment Configuration Pack for Sarbanes-Oxley Act (SOX) - contains configuration items intended to help you establish and validate a desired configuration for your SQL 2005 servers in order to support your Sarbanes-Oxley compliance efforts

SQLIO GUI - user interface for SQLIO Disk Subsystem Benchmark Tool

SQLQueryStress - automatically collects metrics to help you determine whether your queries will perform under load, and what kind of resource strain they put on your server

SQLIO Disk Subsystem Benchmark Tool - used to determine the I/O capacity of a given configuration

SQL Server 2005 Best Practices Analyzer - lets you verify the implementation of common Best Practices in SQL Server 2005

SQL Server 2000 Best Practices Analyzer - lets you verify the implementation of common Best Practices in SQL Server 2000

SQL Server Health and History Tool (SQLH2) - collects information from instances of SQL Server to determine how SQL Server is being used

SQL Server Health and History Tool (SQLH2) Performance Collector - optional tool to collect performance counters that are consumed by the SQLH2

SQL Server Health and History Tool (SQLH2) Reports - reports needed to view the data collected by the SQLH2

SQL Server 2005 Performance Dashboard Reports - performance reports that integrate into SQL Server Management Studio

Microsoft SQL Server 2000/2005 Management Pack - monitors the availability and performance of SQL Server 2000 and 2005 and can issue alerts for configuration problems

Database Publishing to hosted servers

Microsoft SQL Server Database Publishing Wizard - provides a way to publish databases to T-SQL scripts or directly to supporting hosting service providers

Microsoft SQL Server Database Publishing Services - deployed by shared hosting providers to enable publishing of SQL Server databases over the Internet

Upgrade and Migration

Microsoft SQL Server 2005 Upgrade Advisor - used when upgrading from lower SQL Server version to SQL Server 2005

SQL Server Migration Assistant for Access

SQL Server Migration Assistant for Oracle

SQL Server Migration Assistant for Sybase ASE

SQL Server Analysis Services

MDX Script Performance Analyser - allows the user to identify how much each calculated member, named set and scoped assignment in an Analysis Services cube's MDX script contributes to the overall performance of a given MDX query.

Microsoft SQL Server 2005 Data Mining Add-ins for Microsoft Office 2007 - SQL Server 2005 predictive analytics in Office Excel 2007 and Office Visio 2007

SQL Server Integration Services

DTLoggedExec - allows you to run a Sql Server Integration Services (SSIS) Package producing a full and detailed logging information of execution status and package runtime data.

SQL Server 2005 BI Development Studio (BIDS)

BIDS Helper - Add-in for Visual Studio Business Intelligence Development Studio

Samples

SQL Server Analysis Services Product Samples

SQL Server 2005 Samples and Sample Databases

Non MS stuff

SQL CLR Project - a tool that allows you to deploy .NET assemblies to SQL Server. Pretty COOL if you work with SQL CLR a lot

SQL Designer - online SQL Database designer. Contains Importing and Exporting scripts to and from different formats

DbDiff and DbScripting - Compare SQL Server database structures and generate scripts

SQL Accord Community Edition - compares database schema

Quest software's Comparison Suite for SQL Server - tried it... pretty slick

Bypsoft's DBTYP.NET - compares SQL Server, MySQL and Oracle databases. Cross database comparison of schemas and data.

SQL DB Tools - SqlDbDiff, SqlDbSearch and SqlDbSize utility

ClearTrace - utility to easier read your saved trace files

SQL Sripter - data export and scripting utility for Microsoft SQL Server

ScriptDb - data export and scripting utility for Microsoft SQL Server

Idera's Free Tools - SQL Server backup and recovery tool, performance dashboard and logons and permissions transfer tool

SQL and other code Formatting

Jean-Claude Manoli's code formater - online formatting. I use this for my blog's code formatting. Has source code download and formats C#, VB, HTML/XML/ASPX , T-SQL and MSH

SQLinForm - online and desktop versions

Simple Talk's Prettifier - online format tool for T-SQL, C# and VB.

Wangz's Instant SQL Formatter- formats SQL for pretty much all know databases, they also have an add-in for SSMS and QA but it's not fully free so no link :)

Even if none of this stuff helps you at the moment it's good to know they exist.

Because DBA-ing is like a box of chocolates, you never know what you're going to get :)

SQL Server 2005 evil DBA prank

Mladen Prajdić — Thu, 15 Nov 2007 21:05:37 GMT

Today I feel a bit evil minded so I thought I'd share this little prank-friendly function.

If you put this into a .Net Assembly you import to SQL Server as a function or a stored procedure

you can wreck some real havoc :)

private static void SQLPrank()
{
    Random r1 = new Random(DateTime.Now.Millisecond);
    int lowerBound = r1.Next(1000, 2000);
    int upperBound = r1.Next(3000, 4000);
    int randomNumber = r1.Next(1000, 4000);
    /*
    1000             2000             3000             4000
      |----------------|----------------|----------------|
      .....|...................................|..........
    random lower bound                  random upper bound
      ..........................|.........................
                        random number 
      |----|-----------------------------------|---------| 
       Exit          Normal operation             Wait
    */
    if (randomNumber >= 1000 && randomNumber < lowerBound)
        Environment.Exit(0);            
    else if (randomNumber >= upperBound && randomNumber < 4000)
        Thread.Sleep(5000);
}

The gem here is the Environment.Exit(0) which shuts down SQL Server without anyone having a clue why.

This is perfect for a prank on your least favorite DBA or developer. :)