» SQL 2005

Another Reason SQL 2000 should just go away! :)

Colin Stasiuk — Thu, 02 Jul 2009 21:01:13 +0000

Quick without looking it up… what does this script do:

SELECT * FROM dbo.sysfiles WHERE (status & 0x40) <> 0

So if you’re like me and don’t have all the bit compares memorized for all the tables you probably didn’t know that this is how (in SQL 2000) you would query the current database to find all the transaction log files.

Every now and again I take for granted the major jump that was SQL 2000 to SQL 2005 and little things like this just show me how much happier I am working in a SQL 2005/2008 environment.

Let me channel my inner Naughty By Nature here:

You down with DMV…. yeah you know me
You down with DMV… yeah you know me

(Sorry I’m still hurting from not winning SQL Fool’s Rap Contest )

DAMN YOU My humble congratulations to Steve “Flavor Flav” Jones

Now if you were to come across this code:

SELECT * FROM sys.database_files WHERE type_desc = 'LOG'

Wouldn’t you have a much better idea as to what the query is trying to accomplish?

Anyways just another (albeit small) reason why I’m glad to be leaving SQL 2000 in the past.

Enjoy!!

SQL Server 2005 Edition Upgrade

Colin Stasiuk — Wed, 03 Jun 2009 16:30:35 +0000

As most of my posts are inspired by stuff I’ve been working on or have worked on recently this is no different.

A request came in to upgrade a SQL Server 2005 Standard Edition Instance to a SQL Server 2005 Enterprise Edition Instance. Funny thing is that I’ve been working with SQL Server 2005 since it’s release and haven’t had to do this before… weird… so I setup a test box with 2005 STD to play around with and mounted myself a 2005 ENT Edition ISO and ran the GUI setup.

After a bit the wizard told me that in order to upgrade my edition of SQL Server I needed to install via command line and use the SKUUPGRADE switch.

So I googled myself some Books Online goodness cause installing SQL from the command line is not something I do everyday LOL and found this:

How to: Install SQL Server 2005 from the Command Prompt
http://msdn.microsoft.com/en-us/library/ms144259(SQL.90).aspx

[SKUUPGRADE]
Use the SKUUPGRADE parameter when upgrading from one edition of SQL Server to another edition of SQL Server.

Important:
If you use the SKUUPGRADE parameter, Setup will remove all hotfix and service pack updates from the SQL Server instance being upgraded. Once the edition upgrade is complete, you must reapply all hotfix and service pack updates.

To perform an edition upgrade of a default instance of SQL Server (SQL Engine only) via unattended Setup, run the following command using either /qb or /qn:

start /wait setup.exe ADDLOCAL=SQL_Engine INSTANCENAME=MSSQLSERVER UPGRADE=SQL_Engine SKUUPGRADE=1 /qb

The /qb switch allows display of basic Setup dialog boxes. Error messages are also displayed.

The /qn switch suppresses all Setup dialog boxes and error messages. If the /qn switch is specified, all Setup messages, including error messages, are written to Setup log files.

So before doing this I took note of the Service Pack + Hotfix level so that I could reapply them after the edition upgrade was complete.

I ran the script as indicated (after a full backup of course) and it worked like a charm. After reapplying the service pack + hotfixes required to get me back to the same version the users tested and all went as expected.

Not sure how I avoided doing an edition upgrade in the last 5 years or so but it was fun to do something with SQL that was new to me.

and just in case you missed it…

Enjoy!!

Pivot…. I said PIVOT!!!!

Colin Stasiuk — Wed, 28 Jan 2009 14:55:15 +0000

Apparently I must of skipped this entry in BOL when I was going through and memorizing it LOL… I had a “brain fart” yesterday when I tried to use the PIVOT function and I just couldn't get the thing to work. I had used it in the past and thought maybe it was just late in the day and I was missing something in my format of my code. As it ends up it was nothing to do with my code and EVERYTHING to do with the compatibility level of my database (80). PIVOT is only available for databases that are at 90 compatibility mode or higher.

“When PIVOT and UNPIVOT are used against databases that are upgraded to SQL Server 2005 or later, the compatibility level of the database must be set to 90 or higher.”

Here is a good example (taken from Jerry Dixon's blog about the same subject) of how to do a PIVOT if you're in 80 (SQL2000) compatibility mode or 90/100 (SQL2005/SQL2008) compatibility mode.

SQL 2000

SELECT SUM(CASE WHEN MONTH(OrderDate) = 1 THEN 1 END) AS 'January' ,SUM(CASE WHEN MONTH(OrderDate) = 2 THEN 1 END) AS 'February' ,SUM(CASE WHEN MONTH(OrderDate) = 3 THEN 1 END) AS 'March' ,SUM(CASE WHEN MONTH(OrderDate) = 4 THEN 1 END) AS 'April' ,SUM(CASE WHEN MONTH(OrderDate) = 5 THEN 1 END) AS 'May' ,SUM(CASE WHEN MONTH(OrderDate) = 6 THEN 1 END) AS 'June' ,SUM(CASE WHEN MONTH(OrderDate) = 7 THEN 1 END) AS 'July' ,SUM(CASE WHEN MONTH(OrderDate) = 8 THEN 1 END) AS 'August' ,SUM(CASE WHEN MONTH(OrderDate) = 9 THEN 1 END) AS 'September' ,SUM(CASE WHEN MONTH(OrderDate) = 10 THEN 1 END) AS 'October' ,SUM(CASE WHEN MONTH(OrderDate) = 11 THEN 1 END) AS 'November' ,SUM(CASE WHEN MONTH(OrderDate) = 12 THEN 1 END) AS 'December' FROM Sales.SalesOrderHeader WHERE YEAR(OrderDate) = 2002

SQL 2005+

SELECT [1] AS 'January' ,[2] AS 'February' ,[3] AS 'March' ,[4] AS 'April' ,[5] AS 'May' ,[6] AS 'June' ,[7] AS 'July' ,[8] AS 'August' ,[9] AS 'September' ,[10] AS 'October' ,[11] AS 'November' ,[12] AS 'December' FROM ( SELECT MONTH(OrderDate) AS 'MonthNumber' ,OrderID FROM Sales.SalesOrderHeader WHERE YEAR(OrderDate) = 2002 ) AS Data PIVOT( COUNT(OrderID) FOR MonthNumber IN([1],[2],[3],[4],[5],[6],[7],[8],[9],[10],[11],[12]) ) AS PVT

db_Executor Role – updated

Colin Stasiuk — Tue, 27 Jan 2009 14:06:33 +0000

In a passing conversation the question about how you grant execute to all stored procedures to a user came up. In SQL 2005 the ability to grant the execute permission at the database level was introduced. Instead of having to build some 'smarts' into a script to cycle through all your objects, etc you can now solve this problem as easy as:

CREATE ROLE db_executor GRANT EXECUTE TO db_executor EXEC sp_addrolemember 'db_executor', 'username'

So this is an “all or nothing” script so if you're wanting to be selective with which stored procedures you want to grant the permission to than this is not the solution for you… but head on over to facility9 for a look at how you can grant execute on a “pattern” of stored procedures.

UPDATE: As pointed out by K Brian Kelley you might end up with more work in doing this if later down the road there is a stored procedure that you don't want the user to be able to execute. He suggests (and how can you NOT trust an MVP) granting execute not at the database level but at the schema level for more control over what the user can and cannot execute… very sound advice… Thanks!!

SQL Versions, Editions, and Features

Colin Stasiuk — Fri, 07 Nov 2008 15:21:17 +0000

When putting forth a recommendation for a version and edition of SQL Server to install it is important that you understand what features are available in each version and edition.

SQL 2000 – http://msdn.microsoft.com/en-us/library/aa175266.aspx
SQL 2005 – http://msdn.microsoft.com/en-us/library/ms143761(SQL.90).aspx
SQL 2008 – http://msdn.microsoft.com/en-us/library/cc645993.aspx

These 3 websites give you a very detailed look into each version and edition of SQL Server and the features avaliable for each. It always easiest to recommend the newest and hottest for your customers but without evaluating their needs and cross referencing that with the feature lists above they may be spending more money then they need.

(that being said I don’t think recommending a SQL Server 2000 solution would be a great idea either hehehe )

SQL Server 2005 Service Pack 3 BETA released

Colin Stasiuk — Tue, 04 Nov 2008 23:30:33 +0000

SQL Server 2005 Service Pack 3 BETA is now available.

THIS IS A BETA so use with caution. I would advise against applying it to any production servers until the official release of Service Pack 3 and you have fully tested it in your DEV and UAT environments.

Download SQL 2005 SP3 BETA

Release Notes

“Why can’t I see the script behind the stored procedure?”

Colin Stasiuk — Tue, 04 Nov 2008 23:28:12 +0000

ummm I dunno… why can’t you see the script behind the stored procedure? I can see it just fine…. then again I’m sysadmin so if I can’t see it then there is definitely a problem.

Turns out… after all this time with working in SQL 2005 I still learn new things or at least things that I’ve long since forgotten. In production developers have db_datareader access and usually nothing more then that (it’s even more then I think it should be but I usually lose that battle depending on the sensitivity of the data). That being said why shouldn’t a developer have access to view the code or metadata behind the objects within a database? I can understand protecting the metadata from normal users but I can’t think of a good reason why developers should be locked out from this… Turns out that in SQL 2005 you need to actually grant access to do this.

If you want to mimick what was available in SQL 2000 the following 2 statements need to be ran:
GRANT VIEW ANY DEFINITION TO PUBLIC

This allows all server logins to view any metadata in any database
GRANT VIEW SERVER STATE TO PUBLIC

This allows all server logins the ability to see the DMV (Dynamic Management Views) which have replaced the SQL 2000 virtual tables like sysprocesses.

So access to metadata is a privilege by default in SQL 2005. I personally like the approach of meeting somewhere in the middle of SQL 2000 and SQL 2005. I think developers should have the same access and visibility they had in SQL 2000 but “public” shouldn’t be used. I would grant the access to a group something like this…

GRANT VIEW ANY DEFINITION TO DOMAIN\Group
GRANT VIEW SERVER STATE TO DOMAIN\Group

Click here for further information on View Definition Permissions

“Smart” Reindexing (SQL Server 2005, 2008)

Colin Stasiuk — Tue, 04 Nov 2008 23:07:04 +0000

Something that still baffles me about SQL Server is that even in SQL Server 2008 there is no maintenance plan option to do reindexing properly. The key word in that sentence is properly. SQL Server gives you an all or nothing approach to indexing. You have 2 options:

1) Rebuild Indexes

2) Reorganize Indexes

(Great article on the differences between the two : http://decipherinfosys.wordpress.com/2008/02/07/index-rebuilding-vs-index-reorganizing-in-sql-server-2005/ )

If you were to do this through the wizard you can choose individual objects and there are plenty of options to customize but where this falls down is that it does not take into account whether or not an index needs maintenance performed on it.

In SQL Server 2005 DMVs (Dynamic Management Views) were introduced that gave instant access to alot of vital information that prior to SQL Server 2005 wasn’t available or required separate process to gather (anyone remember DBCC SHOWCONTIG?).

Let’s talk about the DMV sys.dm_db_index_physical_stats. “Returns size and fragmentation information for the data and indexes of the specified table or view.” So you would think that with this information readily available that the maintenance plan would have an option to do only the indexes that needed maintenance? nope.

Below is a script that I have been working with for SQL Server 2005 and SQL Server 2008. Because SQL Server 2000 did not have DMVs this script will not work (I have a different script for SQL Server 2000 that I’ll post another time)

The long and the short of what this script does is that it will utilize the sys.dm_db_index_physical_stats DMV and dynamically determine if an index requires maintenance and performs the maintenace.

Variables that require attention
@FragThreshold – This integer value is the minimum percentage that an index is fragmented before maintenance is done

@DoOfflineToo – This bit value indicates whether or not indexes that need to be done offline are done at the same time. This is important because if an index needs to be maintained offline this requires significant locks to the object. (Also please be aware that online index operations are only available on Enterprise or Developer Edition)

This script needs to be run in the context of the database that you are looking to maintain. I usually create an SSIS package and wrap this script in a ForEach loop container that cycles through all the databases but for ease of “blogging” we’ll look at it from a more manual approach.

The “sizzle” of the script is when it decides what to do with the index that is currently being looked at.
DECLARE @FragThreshold INT DECLARE @DoOfflineToo bit


---------------------------------------------------------------
--				VARIABLES TO CHANGE							 --
---------------------------------------------------------------
SELECT @FragThreshold = 10
SELECT  @DoOfflineToo = 0
---------------------------------------------------------------
---------------------------------------------------------------
DECLARE @objectid INT
DECLARE @indexid INT
DECLARE @partitioncount bigint
DECLARE @schemaname VARCHAR(130)
DECLARE @objectname VARCHAR(130)
DECLARE @indexname VARCHAR(130)
DECLARE @indextype INT
DECLARE @partitionnum bigint
DECLARE @partitions bigint
DECLARE @frag INT
DECLARE @command VARCHAR(4000)
DECLARE @max INT
DECLARE @min INT
DECLARE @DB_ID INT
DECLARE @DB_NAME NVARCHAR(128)
DECLARE @IndexListCount INT
DECLARE @Edition NVARCHAR(100)
DECLARE @LobCount INT
SELECT @LobCount = 0
SELECT @DB_ID = DB_ID()
SELECT @DB_NAME = DB_NAME()
SELECT  @Edition = CONVERT(NVARCHAR(100), SERVERPROPERTY ('edition')) 
CREATE TABLE #BenchmarkIndexList (ID INT IDENTITY(1,1), 
   DBName VARCHAR(100), 
   objectID INT,
   indexID INT,
   IndexType VARCHAR(30),
   frag INT,
   avg_frag_size_pages INT,
   page_count INT,
   partition_number INT)
CREATE CLUSTERED INDEX IX_CL_IndexList ON #BenchmarkIndexList(ID)
INSERT #BenchmarkIndexList (DBName, objectID, indexID, IndexType, frag, 
                   avg_frag_size_pages, page_count, partition_number)
SELECT DB_NAME(database_id) AS DBName, OBJECT_ID, index_id, index_type_desc AS 'IndexType',
       avg_fragmentation_in_percent, avg_fragment_size_in_pages, page_count, partition_number
FROM   sys.dm_db_index_physical_stats (@DB_ID, NULL, NULL, NULL, 'LIMITED')
WHERE  page_count > 10 AND 
       index_id > 0 AND 
       avg_fragmentation_in_percent > @FragThreshold AND
       index_type_desc NOT LIKE '%XML%'
       
SELECT @IndexListCount = COUNT(1) FROM #BenchmarkIndexList
SELECT @max = (SELECT MAX(ID) FROM #BenchmarkIndexList)
SELECT @min = 1
WHILE @min <= @max
BEGIN
   SELECT  @objectid = objectID, @indexid = indexID, @partitionnum = partition_number, @frag = frag
   FROM    #BenchmarkIndexList
   WHERE   ID = @min
   SELECT  @objectname = o.name, @schemaname = s.name
   FROM    sys.objects AS o JOIN 
           sys.schemas AS s ON s.schema_id = o.schema_id
   WHERE   o.OBJECT_ID = @objectid
   SELECT  @indexname = name, @indextype = TYPE
   FROM    sys.indexes
   WHERE   OBJECT_ID = @objectid AND 
           index_id = @indexid;
   SELECT  @partitioncount = COUNT(1)
   FROM    sys.partitions
   WHERE   OBJECT_ID = @objectid AND 
           index_id = @indexid
       
   SELECT  @LobCount = COUNT(1)
   FROM    sys.index_columns A INNER JOIN
           sys.columns B ON A.OBJECT_ID = B.OBJECT_ID AND A.Column_id = B.Column_ID INNER JOIN
           sys.types C ON B.system_type_id = C.user_type_id
   WHERE   A.OBJECT_ID = @objectID AND
           A.index_id = @indexID AND 
           (C.name IN('xml','image','text','ntext') OR
           (C.name IN('varchar','nvarchar','varbinary','nvarbinary') AND 
           B.max_length = -1))
   IF @frag < @FragThreshold
   BEGIN
       SET @command = 'ALTER INDEX ' + @indexname + ' ON ' + @schemaname + '.' + @objectname + ' REORGANIZE';
   END
   IF @frag >= @FragThreshold AND @IndexType <> 1 AND @LobCount = 0 AND @Edition = 'Enterprise Edition'
   BEGIN
       SET @command = 'ALTER INDEX ' + @indexname + ' ON ' + @schemaname + '.' + @objectname +' REBUILD WITH(ONLINE = ON, SORT_IN_TEMPDB = ON)';
   END
   IF @frag >= @FragThreshold AND @DoOfflineToo = 1 AND (@IndexType = 1 OR @LobCount <> 0 OR @Edition <> 'Enterprise Edition')
   BEGIN
       SET @command = 'ALTER INDEX ' + @indexname + ' ON ' + @schemaname + '.' + @objectname +' REBUILD WITH(ONLINE = OFF, SORT_IN_TEMPDB = ON)';
   END
   
       IF @frag >= @FragThreshold AND @DoOfflineToo = 0 AND (@IndexType = 1 OR @LobCount <> 0 OR @Edition <> 'Enterprise Edition')
   BEGIN
       SET @command = 'ALTER INDEX ' + @indexname + ' ON ' + @schemaname + '.' + @objectname + ' REORGANIZE';
   END
   IF @partitioncount > 1
   BEGIN
       SET @command = @command + ' PARTITION =' + CAST(@partitionnum AS VARCHAR(10));
       EXEC (@command)
   END
   ELSE
   BEGIN 
       EXEC (@command)
   END
   
   SET @min = @min+1
END
DROP TABLE #BenchmarkIndexList