SQLService blog posts feed

Updated: Microsoft SQL Server Trace Flag list

Updated 2013-05-09 with TF 8002, 4130, 4135, 7826, 7827

We have in our blog written a lot about Microsoft SQL Server Trace Flags, so I thought it was about time to start making a list of known (and unknown) Trace Flags.

First some info to get you started:

What are Microsoft SQL Server Trace Flags?

Trace Flags are settings that in some way or another alters the behaviour of various SQL Server functions.

How do I turn Trace Flags on and off?

- You can use the DBCC TRACEON and DBCC TRACEOFF commands

- You can use the -T option in the startup configuration fo the SQL Server Service

How do I know what Trace Flags are turned on at the moment?

- You can use the DBCC TRACESTATUS command

REMEMBER: Be extremely careful with trace flags, test in yuo test environment first. And consult professionals first if you are the slightest uncertain about the effects of your changes.

So, here is the list, but it is just the beginning. We will continue to add more flags, and more information as we go along

General Links:

SQL Server Central TF List: http://www.sqlservercentral.com/articles/trace+flags/70131/

MSDN TF list: http://sqlserverpedia.com/wiki/Trace_Flags

Albert van der Sel TF list: http://antapex.org/traceflags_sqlserver.txt

Technet Wiki TF list: http://social.technet.microsoft.com/wiki/contents/articles/13105.trace-flags-in-sql-server.aspx

Amit Banerjee TF list: http://troubleshootingsql.com/2012/07/01/sql-server-2008-trace-flags/

Paul Randal discussing TF Pro's and Con's: http://www.sqlskills.com/blogs/paul/the-pros-and-cons-of-trace-flags/

Trace Flag : 107

Function: Alter input rules for decimal numbers

Link : http://support.microsoft.com/kb/203787

Thanks to: http://www.sqlservercentral.com

Trace Flag : 168

Function: Bugfix in ORDER BY

Link : http://support.microsoft.com/kb/926292

Trace Flag : 205

Function: Log usage of AutoStat/Auto Update Statistics

Link : http://support.microsoft.com/kb/195565

Trace Flag : 260

Function: Prints Extended stord proc DLL versioning info

Link : http://msdn.microsoft.com/en-us/library/ms188396.aspx

Trace Flag : 610

Function: Minimally logged inserts to indexed tables

Link : http://msdn.microsoft.com/en-us/library/dd425070%28v=SQL.100%29.aspx

Trace Flag : 652

Function: Disable page pre-fetching scans

Link : http://support.microsoft.com/kb/920093

Trace Flag : 661

Function: Disable the ghost record removal process

Link : http://support.microsoft.com/kb/920093

Trace Flag : 834

Function: Large Page Allocations

Link : http://sqlservice.se/sv/start/blogg/nagra-trace-flags-for-sql-server.aspx

Link : http://support.microsoft.com/kb/920093

Trace Flag : 836

Function: Use the max server memory option for the buffer pool

Link : http://support.microsoft.com/kb/920093

Trace Flag : 845

Function: Enable Lock pages in Memory on Standard Edition

Link : http://sqlservice.se/sv/start/blogg/sql-server-performance-with-dynamics-axapta.aspx

Trace Flag : 902

Function: Bypass Upgrade Scripts

Link : http://sqlservice.se/sv/start/blogg/sql-server-2012-cu1-upgrade-step--msdb110_upgrade-sql--encountered-error-547.aspx

Trace Flag : 1117

Function: Simultaneous Autogrowth in Multiple-file database

Link : http://sqlservice.se/sv/start/blogg/nagra-trace-flags-for-sql-server.aspx

Link : http://blogs.technet.com/technet_blog_images/b/sql_server_sizing_ha_and_performance_hints/archive/2012/02/09/sql-server-2008-trace-flag-t-1117.aspx

Trace Flag : 1118

Function: Force Uniform Extent Allocation

Link : http://sqlservice.se/sv/start/blogg/nagra-trace-flags-for-sql-server.aspx

Link : http://blogs.msdn.com/b/psssql/archive/2008/12/17/sql-server-2005-and-2008-trace-flag-1118-t1118-usage.aspx

Trace Flag : 1204

Function: Returns info about deadlocks

Link : http://msdn.microsoft.com/en-us/library/ms188396.aspx

Trace Flag : 1211

Function: Disables Lock escalation caused by mem pressure

Link : http://msdn.microsoft.com/en-us/library/ms188396.aspx

Trace Flag : 1222

Function: Returns Deadlock info in XML format

Link : http://msdn.microsoft.com/en-us/library/ms188396.aspx

Trace Flag : 1224

Function: Disables lock escalation based on number of locks

Link : http://msdn.microsoft.com/en-us/library/ms188396.aspx

Trace Flag : 1264

Function: Collect process names in non-yielding scenario memory dumps

Link : http://support.microsoft.com/kb/2630458/en-us

Trace Flag : 1448

Function: Alters replication logreader functionality

Link : http://msdn.microsoft.com/en-us/library/ms188396.aspx

Trace Flag : 1462

Function: Disable Mirroring Log compression

Link : http://sqlcat.com/sqlcat/b/technicalnotes/archive/2007/09/17/database-mirroring-log-compression-in-sql-server-2008-improves-throughput.aspx

Trace Flag : 2301

Function: Enable advanced decision support optimizations

Link : http://support.microsoft.com/kb/920093

Trace Flag : 2335

Function: Generates Query Plans optimized for less memory

Link : http://support.microsoft.com/kb/2413549

Trace Flag : 2340

Function: Disable specific SORT optimization in Query Plan

Link : http://support.microsoft.com/kb/2009160

Trace Flag : 2371

Function: Change threshold for auto update stats

Link : http://www.sqlservice.se/sv/start/blogg/sql-server--auto-update-stats-part-2.aspx

Trace Flag : 2389

Function: Enable auto-quick-statistics update for known ascending keys

Link : http://sqlservice.se/sv/start/blogg/sql-server-statistics--traceflags-2389--2390.aspx

Link: http://blogs.msdn.com/b/ianjo/archive/2006/04/24/582227.aspx

Link: http://www.sqlmag.com/article/tsql3/making-the-most-of-automatic-statistics-updating--96767

Trace Flag : 2390

Function: Enable auto-quick-statistics update for all columns

Link : http://sqlservice.se/sv/start/blogg/sql-server-statistics--traceflags-2389--2390.aspx

Link: http://blogs.msdn.com/b/ianjo/archive/2006/04/24/582227.aspx

Link: http://www.sqlmag.com/article/tsql3/making-the-most-of-automatic-statistics-updating--96767

Trace Flag : 2430

Function: Fixes performance problem when using large numbers of locks

Link : http://support.microsoft.com/kb/2754301/en-us

Trace Flag : 2470

Function: Fixes performance problem when using AFTER triggers on partitioned tables

Link : http://support.microsoft.com/kb/2606883/en-us

Trace Flag : 2528

Function: Disables parallellism in CHECKDB etc.

Link : http://msdn.microsoft.com/en-us/library/ms188396.aspx

Trace Flag : 2540

Function: Unknown, but related to controlling the contents of a memorydump

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2541

Function: Unknown, but related to controlling the contents of a memorydump

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2542

Function: Unknown, but related to controlling the contents of a memorydump

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2543

Function: Unknown, but related to controlling the contents of a memorydump

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2544

Function: Produces a full memory dump

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2545

Function: Unknown, but related to controlling the contents of a memorydump

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2546

Function: Dumps all threads for SQL Server in the dump file

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2547

Function: Unknown, but related to controlling the contents of a memorydump

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2548

Function: Unknown, but related to controlling the contents of a memorydump

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2549

Function: Faster CHECKDB

Link: http://sqlservice.se/sv/start/blogg/faster-dbcc-checkdb-by-using-trace-flag-2562-and-2549.aspx

Link : http://blogs.msdn.com/b/saponsqlserver/archive/2011/12/22/faster-dbcc-checkdb-released-in-sql-2008-r2-sp1-traceflag-2562-amp-2549.aspx

Link : http://support.microsoft.com/kb/2634571

Link: http://support.microsoft.com/kb/2732669/en-us

Trace Flag : 2550

Function: Unknown, but related to controlling the contents of a memorydump

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2551

Function: Produces a filtered memory dump

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2552

Function: Unknown, but related to controlling the contents of a memorydump

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2553

Function: Unknown, but related to controlling the contents of a memorydump

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2554

Function: Unknown, but related to controlling the contents of a memorydump

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2555

Function: Unknown, but related to controlling the contents of a memorydump

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2556

Function: Unknown, but related to controlling the contents of a memorydump

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2557

Function: Unknown, but related to controlling the contents of a memorydump

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2558

Function: Unknown, but related to controlling the contents of a memorydump

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2559

Function: Unknown, but related to controlling the contents of a memorydump

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 2562

Function: Faster CHECKDB

Link: http://sqlservice.se/sv/start/blogg/faster-dbcc-checkdb-by-using-trace-flag-2562-and-2549.aspx

Link : http://blogs.msdn.com/b/saponsqlserver/archive/2011/12/22/faster-dbcc-checkdb-released-in-sql-2008-r2-sp1-traceflag-2562-amp-2549.aspx

Link : http://support.microsoft.com/kb/2634571

Link: http://support.microsoft.com/kb/2732669/en-us

Trace Flag : 3042

Function: Alters backup compression functionality

Link : http://msdn.microsoft.com/en-us/library/ms188396.aspx

Trace Flag : 3101

Function: Fix performance problems when restoring database with CDC

Link : http://support.microsoft.com/kb/2567366/en-us

Trace Flag : 3205

Function: Disable HW compression for backup to tape drives

Link : http://msdn.microsoft.com/en-us/library/ms188396.aspx

Trace Flag : 3213

Function: Output buffer info for backups to ERRORLOG

Link : http://sqlcat.com/sqlcat/b/technicalnotes/archive/2008/04/21/tuning-the-performance-of-backup-compression-in-sql-server-2008.aspx

Trace Flag : 3226

Function: Turns off "Backup Successful" messages in errorlog

Link : http://msdn.microsoft.com/en-us/library/ms188396.aspx

Thanks to: @lwiederstein /https://twitter.com/lwiederstein)

Trace Flag : 3604

Function: Redirect DBCC command output to query window

Link : http://blogs.msdn.com/b/askjay/archive/2011/01/21/why-do-we-need-trace-flag-3604-for-dbcc-statements.aspx Link: http://sqlservice.se/sv/start/blogg/querytraceon.aspx

Trace Flag : 3605

Function: Output buffer info for backups to ERRORLOG

Link : http://sqlcat.com/sqlcat/b/technicalnotes/archive/2008/04/21/tuning-the-performance-of-backup-compression-in-sql-server-2008.aspx

Trace Flag : 3608

Function: Recover only Master db at startup

Link : http://msdn.microsoft.com/en-us/library/ms188396.aspx

Trace Flag : 3625

Function: Masks some errormessages

Link : http://msdn.microsoft.com/en-us/library/ms188396.aspx

Trace Flag : 3656

Function: Enables resolve of all callstacks in extended events

Link : http://sqlcat.com/sqlcat/b/msdnmirror/archive/2010/05/11/resolving-dtc-related-waits-and-tuning-scalability-of-dtc.aspx

Trace Flag : 3688

Function: Removes messages to errorlog about traces started and stopped

Link : http://support.microsoft.com/kb/922578/en-us

Trace Flag : 4022

Function: Bypass Startup procedures

Link : http://sqlservice.se/sv/start/blogg/sql-server-2012-cu1-upgrade-step--msdb110_upgrade-sql--encountered-error-547.aspx

Trace Flag : 4130

Function: XML performance fix

Link : http://support.microsoft.com/kb/957205

Trace Flag : 4135

Function: Bugfix for error inserting to temp table

Link : http://support.microsoft.com/kb/960770

Trace Flag : 4136

Function: Parameter Sniffing behaviour alteration

Link : http://blogs.msdn.com/b/axinthefield/archive/2010/11/04/sql-server-trace-flags-for-dynamics-ax.aspx

Link : http://sqlservice.se/sv/start/blogg/nagra-trace-flags-for-sql-server.aspx

Trace Flag : 4137

Function: Fix for bad performance in queries with several AND criteria

Link : http://support.microsoft.com/kb/2658214

Trace Flag : 4138

Function: Fixes performance probles with certain queries that use TOP statement

Link : http://support.microsoft.com/kb/2667211

Trace Flag : 4199

Function: Turn on all optimizations

Link : http://sqlservice.se/sv/start/blogg/one-trace-flag-to-rule-them-all.aspx

Trace Flag : 4616

Function: Alters server-level metadata visibility

Link : http://msdn.microsoft.com/en-us/library/ms188396.aspx

Trace Flag : 6527

Function: Alters mem dump functionality

Link : http://msdn.microsoft.com/en-us/library/ms188396.aspx

Trace Flag : 7806

Function: Enables DAC on SQL Server Express

Link : http://msdn.microsoft.com/en-us/library/ms188396.aspx

Trace Flag : 7826

Function: Disable Connectivity ringbuffer

Link : http://blogs.msdn.com/b/sql_protocols/archive/2008/05/20/connectivity-troubleshooting-in-sql-server-2008-with-the-connectivity-ring-buffer.aspx

Trace Flag : 7827

Function: Record connection closure info in ring buffer

Link : http://blogs.msdn.com/b/sql_protocols/archive/2008/05/20/connectivity-troubleshooting-in-sql-server-2008-with-the-connectivity-ring-buffer.aspx

Link: https://connect.microsoft.com/SQLServer/feedback/details/518158/-packet-error-a-fatal-error-occurred-while-reading-the-input-stream-from-the-network

Trace Flag : 8002

Function: Changes CPU Affinity behaviour

Link : http://support.microsoft.com/kb/818769

Trace Flag : 8010

Function: Fixes problem that SQL Server services can not be stopped

Link : http://support.microsoft.com/kb/2633271/en-us

Trace Flag : 8011

Function: Disable the ring buffer for Resource Monitor

Link : http://support.microsoft.com/kb/920093

Trace Flag : 8012

Function: Disable the ring buffer for schedulers

Link : http://support.microsoft.com/kb/920093

Trace Flag : 8015

Function: Ignore NUMA functionality

Link : http://sql-sasquatch.blogspot.se/2013/04/startup-trace-flags-i-love.html

Thanks to: @sql_handle (https://twitter.com/sql_handle)

Trace Flag : 8018

Function: Disable the exception ring buffer

Link : http://support.microsoft.com/kb/920093

Trace Flag : 8019

Function: Disable stack collection for the exception ring buffer

Link : http://support.microsoft.com/kb/920093

Trace Flag : 8020

Function: Disable working set monitoring

Link : http://support.microsoft.com/kb/920093

Trace Flag : 8026

Function: SQL Server will clear a dumptrigger after generating the dump once

Link : http://support.microsoft.com/kb/917825/en-us

Trace Flag : 8030

Function: Fix for performance bug

Link : http://support.microsoft.com/kb/917035

Link : http://sqlservice.se/sv/start/blogg/sql-server-2005-slowing-down-after-a-while.aspx

Trace Flag : 8032

Function: Alters cache limit settings

Link : http://msdn.microsoft.com/en-us/library/ms188396.aspx

Trace Flag : 8048

Function: NUMA CPU based partitioning

Link : http://sql-sasquatch.blogspot.se/2013/04/startup-trace-flags-i-love.html

Link: http://blogs.msdn.com/b/psssql/archive/2012/12/20/how-it-works-cmemthread-and-debugging-them.aspx

Link: http://blogs.msdn.com/b/psssql/archive/2011/09/01/sql-server-2008-2008-r2-on-newer-machines-with-more-than-8-cpus-presented-per-numa-node-may-need-trace-flag-8048.aspx

Thanks to: @sql_handle (https://twitter.com/sql_handle)

Related to: 8015, 9024

Trace Flag : 8207

Function: Alters Transactional Replication behaviour of UPDATE statement

Link : http://msdn.microsoft.com/en-us/library/ms188396.aspx

Trace Flag : 8209

Function: Output extra infomation to errorlog regarding replication of schema changes in SQL Server Replication

Link : http://support.microsoft.com/kb/916706/en-us

Trace Flag : 8602

Function: Disable Query Hints

Link : http://www.sqlservice.se/sv/start/blogg/sql-server-trace-flag-8602.aspx

Trace Flag : 8649

Function: Set Cost Threshold for parallelism to 0

Link : http://www.sqlservice.se/sv/start/blogg/enable-parallellism-for-specific-query.aspx

Trace Flag : 8744

Function: Disable pre-fetching for ranges

Link : http://support.microsoft.com/kb/920093

Trace Flag : 9024

Function: Performance fix for AlwaysON log replication

Link : http://support.microsoft.com/kb/2809338/en-us

Related to: 8048

Trace Flag : 9485

Function: Disables SELECT permission for DBCC SHOW_STATISTICS.

Link : http://msdn.microsoft.com/en-us/library/ms188396.aspx

Index Hint - With ( Index ( 0 ) )

En möjlighet som man har när man skriver SQL kod är att ange sk index hints. Att man använder dessa är inte alltför vanligt, men det förekomer ibland. När man gör detta så måste man ha klart för sig att detta i framtiden kanske inte var så smart. Datavolymerna växer, innehållet i tabellerna förändras, nya index tillkommer osv. Ett av de sämre sätten är att ange WITH ( INDEX ( 0 ) ) som innebär att det alltid blir en scan av tabellen eller det det klustrade index'et och detta kan vara riktigt dåligt som vi ser nedan.

Om vi kör denna fråga :

USE [AdventureWorks2012];

SELECT  [BusinessEntityID] ,
        [LastName]
FROM    [AdventureWorks2012].[Person].[Person] WITH ( INDEX ( 0 ) )
WHERE   [BusinessEntityID] = 1;

Detta ger denna statistik för en enda rad som resultat av frågan:

Om man däremot kör samma fråga utan att peka ut något index ...

SELECT  [BusinessEntityID] ,
        [LastName]
FROM    [AdventureWorks2012].[Person].[Person] 
WHERE   [BusinessEntityID] = 1;

. så blir det helt annan statistik:

Exekveringsplanerna för dessa frågor visar också vilken skillnad det är på dem och från verkligheten kan man ske skillnader när det gäller svarstider på t.ex millisekunder jämfört med minuter.

PowerPivot tool -DAX Studio

If you work with PowerPivot in Excel, you probably are familiar with DAX. To make your work with DAX easier, you should download the DAX studio from CodePlex that includes features as Object Browser, query editing and execution, formula and measure editing ,syntax highlighting, integrated tracing and query execution breakdowns.

Prepare yourself - the end is near

Well, at least the end of mainstream support for Microsoft SQL Server 2008 and 2008R2 is near. The mainstream support ends 7/8/2014 and you should prepare yourself and your SQL server environment for SQL server 2012. To prepare yourself you can sign up for a class at www.informator.se or www.labcenter.se and to prepare your environment you can contact us for help with consolidation to save money or upgrade support. You can also sign up for a SQL service agreement for your SQL server.

/Håkan Winther
COO
SQL Service

Ny uppdatering av SQL Server 2012 RTM

Sedan förra veckan finns en ny uppdatering för SQL Server 2012 RTM. Observera alltså att denna inte gäller för service pack 1 där nästa uppdatering kommer om ungefär en månad.

Denna uppdatering innehåller 17 rättningar, och nedan följer några av dessa:

FIX: Slow performance when you run the SSIS Server Maintenance Job to remove old data in SQL Server 2012
FIX: Incorrect results when you run a FULL JOIN query that uses the CROSS APPLY clause in SQL Server 2008 R2 or in SQL Server 2012

Cumulative update package 7 for SQL Server 2012

Som vanligt gäller det att alltid testa innan man gör förändringar i sin produktionsmiljö, men man bör alltid kontrollera vilka förbättringar som gjorts i dessa uppdateringar och vem vill inte ha löst dessa problem som man kan ha i sin SQL Server miljö.

Rättigheter för användarna

När det gäller rättigheter för användarna i databaserna finns det ingen möjlighet att se detta i SQL Server Management Studio på ett överskådligt sätt. Nedan är ett exempel som bättre visar de olika användarna och dess rättigheter och där vi kan se några av kolumnerna från SQL koden som följer längre ned.

Att de råder förrvirring om vilka rättighet man egentligen behöver för de olika användarna och dess roller möter vi ganska ofta. Ofta verkar det ha slutat med att man sätter sysadmin och detta är förstås inte bra, då det innebär totalt frihet att göra allt på servern.

Mer om databasroller kan man läsa här och om serverroller finns information här.

Nedan följer koden som visar de olika användarna för hela servern och dess databaser och den kan man förstås modifiera för att passa ens smak och tycke bättre

DECLARE @DB_USers TABLE
(DatabaseName sysname, UserName sysname, LoginType sysname, DBRoleName varchar(max),
	CreateDate datetime, ModifyDate datetime, ServerRoleName varchar(max))

INSERT @DB_USers
EXEC sp_MSforeachdb

'USE [?]

SELECT ''?'', Users.Name, Users.Type_Desc,  UserDBRole.DBRoleName, Users.Create_date, 
	ISNULL(UserDBRole.Modify_date, Users.Modify_date), ServerRole.name
FROM sys.server_principals Users

OUTER APPLY
(
SELECT
	prin.name, 
	ISNULL(USER_NAME(mem.role_principal_id),'''') AS DBRoleName,
	Create_date, Modify_date
FROM sys.database_principals prin
	LEFT OUTER JOIN sys.database_role_members mem ON prin.principal_id=mem.member_principal_id
WHERE prin.sid IS NOT NULL and prin.sid NOT IN (0x00) and
	prin.is_fixed_role <> 1 AND prin.name NOT LIKE ''##%'' AND
	prin.name COLLATE Finnish_Swedish_CI_AS = Users.Name COLLATE Finnish_Swedish_CI_AS
) UserDBRole

OUTER APPLY
(
	SELECT principals.name
	FROM
		sys.server_principals principals
		INNER JOIN sys.server_role_members members ON 
			principals.principal_id = members.role_principal_id
		INNER JOIN sys.server_principals principals2 ON 
			principals2.principal_id = members.member_principal_id
	WHERE principals2.name  = Users.Name
) ServerRole

WHERE NOT Users.Name IN (''NT AUTHORITY\SYSTEM'')
	AND (NOT ServerRole.name IS NULL OR NOT UserDBRole.name IS NULL)' 

SELECT
	DatabaseName, LoginType, UserName, CreateDate AS CreateDate, ModifyDate,

	STUFF(
	(
	SELECT DISTINCT ',' + CONVERT(VARCHAR(500),ServerRoleName)
	FROM @DB_USers user2
	WHERE
		user1.DatabaseName=user2.DatabaseName AND user1.UserName=user2.UserName 
	FOR XML PATH('')
	)
	,1,1,'') AS ServerRoleName	,
	
	STUFF(
	(
	SELECT DISTINCT ',' + CONVERT(VARCHAR(500),DBRoleName)
	FROM @DB_USers user2
	WHERE
		user1.DatabaseName=user2.DatabaseName AND user1.UserName=user2.UserName
	FOR XML PATH('')
	)
	,1,1,'') AS DBRoleName

FROM @DB_USers user1

GROUP BY DatabaseName, UserName ,LoginType ,CreateDate ,ModifyDate
ORDER BY DatabaseName, LoginType, UserName

Nya förbättringar för SQL Server 2008 R2

Nu finns möjlighet att ladda ner nya förbättringar för SQL Server 2008 R2 i och med att nya sk kumulativa uppdateringar släppts.

Observera att dessa är olika beroende på vilken service pack man har installerat och man måste välja rätt version. Om man av någon anledning inte vet vilken SQL Server version man har installerat kan man t.ex. använda denna SQL kod:

SELECT @@VERSION

Cumulative update package 6 for SQL Server 2008 R2 SP2

Cumulative update package 12 for SQL Server 2008 R2 SP1

Som vanligt gäller det att alltid testa innan man gör förändringar i sin produktionsmiljö, men man bör alltid kontrollera vilka förbättringar som gjorts i dessa uppdateringar.

Mer om SQL Server 2012 på RunAsRadio

Som vi skrivit tidigare så finns det utmärkta möjlighet att lära sig mer om SQL Server på denna informationskanal, som inte enbart handlar om SQL Server. Som regel är varje session på dryga halvtimmen och senaste SQL Server sessionen är :

Brent Ozar Updates Us On SQL Server 2012

SQL server INSTEAD OF TRIGGER

First of all, I am not a fan of triggers because of a number of reasons, but i will not go into those in this blog. Anyway, triggers can be useful sometimes, and there are two types of triggers, AFTER trigger and INSTEAD OF TRIGGER. In this blog, I'll focus on the INSTEAD OF TRIGGER.

When this trigger is fired it will handle all records in the same call. That means that you need to take care of all the records in the INSERTED or UPDATED table and update your undlerlying table. Take a look at this sample:

SET ANSI_NULLS ON
GO
IF EXISTS (SELECT * FROM [INFORMATION_SCHEMA].TABLES t WHERE t.[TABLE_SCHEMA] ='dbo' AND t.[TABLE_NAME] = 'triggerTest')
	DROP TABLE [dbo].[triggerTest]
GO
	 
SET QUOTED_IDENTIFIER ON
GO

SET ANSI_PADDING ON
GO

CREATE TABLE [dbo].[triggerTest](
	[col1] [int] IDENTITY(1,1) NOT NULL,
	[myName] [varchar](50) COLLATE Finnish_Swedish_CI_AS NOT NULL,
	lastUpdated DATE NULL
 CONSTRAINT [PK_triggerTest] PRIMARY KEY CLUSTERED 
(
	[col1] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON, FILLFACTOR = 80) ON [PRIMARY]
) ON [PRIMARY]

GO

SET ANSI_PADDING OFF
GO

SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO

CREATE TRIGGER dbo.trigg 
   ON  dbo.triggerTest 
   INSTEAD OF INSERT
AS 
BEGIN
	SET NOCOUNT ON;
	
	-- get the records from inserted table
 	DECLARE @name VARCHAR(50)
	SELECT @name =	[myName] FROM INSERTED

	IF EXISTS(SELECT [myName] FROM [dbo].[triggerTest] WHERE [myName] = @name)
		UPDATE [dbo].[triggerTest]
		SET lastUpdated = GETDATE()
		WHERE [dbo].[triggerTest].[myName] = @name 
	ELSE
		-- insert the records in the table
		INSERT INTO dbo.[triggerTest] ([myName])
		VALUES (@name)   
END
GO


-- insert three records in triggerTest
INSERT INTO [dbo].[triggerTest] 
	([myName])
VALUES
	('Håkan Winther'),
	('Jan Nieminen'),
	('Göran Rönnbäck')

-- and take a look at the result
SELECT * FROM dbo.[triggerTest] AS tt 

--as you can see, only one record is inserted
--that's because the instead of trigger is 
--handling all records in the same call
--and my trigger is only handling one record

GO

ALTER TRIGGER dbo.trigg 
   ON  dbo.triggerTest 
   INSTEAD OF INSERT
AS 
BEGIN
	SET NOCOUNT ON;
	
	-- update existing records
	UPDATE [dbo].[triggerTest]
	SET lastUpdated = GETDATE()
	WHERE [dbo].[triggerTest].[myName] IN (SELECT [myName] FROM INSERTED)

	-- insert the new records in the table
	INSERT INTO dbo.[triggerTest] ([myName])
	SELECT i.[myName] FROM INSERTED I 
	LEFT JOIN [dbo].[triggerTest] AS TT 
	ON I.myName = tt.[myName]
	WHERE tt.col1 IS NULL
END
GO

-- insert three records in triggerTest
INSERT INTO [dbo].[triggerTest] 
	([myName])
VALUES
	('Håkan Winther'),
	('Jan Nieminen'),
	('Göran Rönnbäck')

-- and take a look at the result
SELECT * FROM dbo.[triggerTest] AS tt

As you can see, before we changed the trigger, only the last record is inserted (or updated). After the trigger was changed to use the INSERTED table, the complete set of records was inserted or updated. Make sure you take care of all records in the trigger, otherwise you are in serious trouble.

If you have any SQL server related questions, feel free to contact any of our SQL server consultants and we will help you.

Håkan Winther
twitter: @h_winther

SQLIntersection - Execution Plans

Som sagt gäller det olika spår varje dag på SQLIntersection, och så den 5:e dagen handlade det enbart om Execution Plans för min del. Första sessionen med Grant Fritchey om "Tune Queries by Fixing Bad Parameter Sniffing". Normalt och oftast så fungerar "Parameter Sniffing" bra, men ibland blir det väldigt dåligt och det är ofta då vi märker problemen, det svänger i prestandan på samma fråga kan man tycka. För att lösa det måste man till att börja ha uppdaterad statistik. Kanske inte det hjälper pga man har har väldigt skev statistik och då har man har välja bland olika sätt med dess för- och nackdelar t.ex. lokala variabler, optimize for value, optimize for unknown, recompile, plan guides osv. Dessutom kan man faktiskt slå av parameter sniffing med en traceflagga, men det vill man förstås inte. Att rekommendera är också läsa Grants bok "SQL Server 2008 Query Performance Tuning Distilled" som är en klassiker och handlar väldigt mycket om exekveringsplaner.

Resten av dagen höll Paul White två sessioner om just exekveringsplaner, Han började med "I love execution plans" och det är inget tvivel om :-). Del 1 på 200 nivå gick han igenom hur man skall läsa en exekveringsplan och vad man bör inrikta sig på t.ex. stora skillnader mellan estimate och actual number of rows, tjockleken på linjerna, scans, lookups, onödiga sorteringar osv. Del 2 på 400 nivå bestod till skillnad från del 1 av bara en overhead och resten med massor av exempel. Paul White är ju känd för att ha testat allt för att se vilka skillnader det blir i exekveringsplanerna och resultaten och det visade han också. Nedan är ett exempel av detta och där kan man tycka att det borde visa samma resultat i båda fallen.

SQL Server och portar

SQL Server lyssnar ju som bekant by default på port 1433 om man installerar en default instans. Installerar man en namngiven instans kan man välja att antingen låta SQL Server lyssna på en port dynamiskt eller så anger man en port som den skall lyssna på.

Men kan man ha mer än en port? Ja det kan man. Detta kan man göra mha Configuration Manager.

Detta gör man via SQL Server Network Configuration i Configuration Manager. Däri väljer man sedan ut den instans man vill ändra, klickar på fliken IP Addresses och IP ALL. Här kan man sedan ange sina portar åtskiljda med kommatecken som man vill att SQL Server skall lyssna på.

Efter detta måste man som vanligt starta om SQL tjänsten innan ändringen slår igenom.

Om man nu vill testa att detta fungerar kan vi enkelt göra det med Management Studio. Vi börjar med att stänga av SQL Server Browser. Efter det kan vi prova att koppla upp vår instans med rätt portnummer. I exemplet ovan hade jag en instans som heter SQL2012 där jag angav portar: 1205 och 1206. I och med att jag stängt av SQL Server Browser, och vill koppla upp en namngiven instans, så måste jag även ange port:

Vi kan här se att SQL Server nu lyssnar på mer än en port. En titt i error loggen bekräftar detta:

SQLIntersection - Virtualize & Azure

Dag 4 inledde jag med "Oh No! They're Making Me Virtualize!" av Brent Ozar. Han gick igenom de olika steg som ev innebär att man beslutar att flytta sina databaser till en virtuell värld. I korthet sammafattat att man till att börja med mäter i sin nuvarande miljö, sedan avgör beroende på flaskhalsarna om databasen överhuvudtaget skall flyttas och till sist genomför med de inställningar man måste göra i sin SQL Server miljö samt att sedan bevaka genom att fortsätta mäta. En mycket bra dragning och som vid handuppräckning visade att enstaka är nöjda med prestanda i sin virtuella värld och att de allra flesta använder VMware.

En annan session visade att Azure inte blivit något hit ännu bland oss utvecklare. På Grant Fritcheys session "Query Tuning in the Clouds" var vi 5 totalt i rummet ?. Hur som helst en bra dragning som visar att det blir än viktigare att designa och koda smart och rätt. Han visade de verktyg som vi har att använda SSMS, SQL Management Portal och DMV's. Nyttig dragning för mig och det är klart att det blir diskussioner med Aaron Bertrand från SQL Sentry med verktyget Plan Explorer i rummet när vi tittade på exekveringsplanen som man får från portalen.

Ytterligare en bra dag alltså :-)

SQL Server statistics - traceflags 2389 & 2390

A common problem with statistics is when it's based on an index with an incrementing column, like an IDENTITY column or a DATETIME column that is behaving like a time stamp. The problem occurs when you have a large table and you add more records (less than 20% of the number of existing records) and then tries to select those newly added records. As the auto update statistics is only triggered when 20% of the records are updated, you'll have statistics that are "out of date" and doesn't know anything about the new records.

This lack of statistics will cause the SQL optimizer to choose a plan that is based on the assumption that there are only one records for the incrementing column, and that's usually a bad idea from a performance perspective.

When you select records, you'll see differences between the estimated and actual number of records.

Since SQL server 2005 SP1, there are two undocumented (and unsupported) trace flags that can be used to solve this issue and they also applies to SQL2008, SQL2008R2 and SQL2012. Traceflag 2389 will enable auto-quick-statistics update for known ascending keys and 2390 will enable auto-quick-statistics update for all columns, known ascending or unknown.

What does that mean? Well, when the statistics are seen to increase three times the column is branded ascending. If trace flag 2389 is set, and a column is branded ascending, and an index exists with that ascending column as the leading key, then the statistics will be updated automatically at query compile time. SQL Server finds the highest value and adds a new step at the end of the existing histogram.

Lets look at a sample

-- create a table with values from 1 to 200 000
SELECT * 
INTO dbo.IncreasingColumn
FROM dbo.[fnNumsTable](1,200000,1) AS fnt; -- this function generates records from x to Y

-- create a clustered index
CREATE CLUSTERED INDEX ix ON dbo.IncreasingColumn (n);

-- the statistics is up to date
-- take a look at the execution plan
-- as you can see, the estimated and the actual number of records match
SELECT n FROM dbo.increasingColumn WHERE n > 200000

-- lets add 100 records
-- not enough to trigger the auto update stats 
INSERT INTO dbo.IncreasingColumn
SELECT n
FROM [SQLServiceTools].dbo.[fnNumsTable](200001,200100,1) AS fnt;

--if you compare the estimated and actual number of records,
--you'll notice that estimated number of records is only 1
-- this is beacause the value I am lookin for is not within range in
-- the statistics 
SELECT n FROM dbo.increasingColumn WHERE n > 200000

-- let's activate the trace flags
DBCC TRACEON(2389,2390);

-- and compare the actual and estimated again.
-- now they match each other, exactly what we want
SELECT n FROM dbo.increasingColumn WHERE n > 200000 OPTION(RECOMPILE)

As you can see in the actual execution plan, with the trace flags active you'll get more accurate statistics and that's a good thing for your performance. When you have accurate statistics it's more likely that SQL server optimizer will choose a good plan and the right indexes depending on the number of records you'll trying to get.

You can activate the trace flags on Global, Session or Statement level ( by using OPTION(QUERYTRACEON 2390,QUERYTRACEON 2389, RECOMPILE) ), but you have to be a member of the sysadmin role.

If you experience performancec issues, call us and our SQL server consultants will help you.

/Håkan Winther
Twitter: @h_winther

SQL Server trace flag 8602

Sometimes you may stumble upon a slow running query in SQL server and when you look at the code you find an index hint. In normal cases the query runs fast and you need to investigate why the the query suddenly runs slower. One option you could try is to remove the query hint and run the query to see if you get a different execution plan and faster query. An easier way without changing the query is to use the trace flag 8602. This trace flag disables all index hints in your session or at a global level.

You can try the code below to see the difference.

USE [AdventureWorks2008R2]
GO

CREATE PROCEDURE Sales.spGetCustomerWithIndexHint @customerID INT = NULL
AS
SELECT * 
FROM Sales.Customer c WITH(INDEX(AK_Customer_AccountNumber)) -- force a specific (incorrect) index for demonstration 
WHERE 
	c.[CustomerID] = @customerID;
GO

SET STATISTICS IO ON;
SET STATISTICS TIME ON;

--execute the procedure
EXEC Sales.spGetCustomerWithIndexHint 1

--activate the traceflag and try again
DBCC TRACEON(8602,-1)
GO
EXEC Sales.spGetCustomerWithIndexHint 1
DBCC TRACEOFF(8602)
GO
--compare the execution plans 
--and the statistics time and IO in the message window
--as you can see when using the index hint,
--you get and index scan and a key lookup
--Without the index hint, you get an clustered index seek

In this case, you notice that the index you are trying to force is causing SQL server to do key lookups and is causing the performance issues. To solve this issue you remove the index hint or change the query to return only the columns you need and change the index to include all the columns you have specified in the query.

Index hints can sometimes help, but as your database grow and data is changing, you might end up in a situation where SQL server should have chosen a faster execution plan.

If you are experiencing performance issues, feel free to contact us, and our highly skilled SQL server consultants will help you.

/Håkan Winther
@h_winther

Finding prime numbers with SQL server

Today I just wanted to have a little fun, while at the same time brushing off my T-SQL skills. As you know, prime numbershave many uses, for example in encryption. And while they are easy to find in the beginning, it gets increasingly harder as the numbers go up. Below is the little snippet of code that prints out prime numbers.

It has 2 parameters that you can use to control it, @a is the first number to evaluate and @b is the last.

The rest is basically 2 nested loops, one that counts from @a to @b, and one that evaluates @a to see if it is a prime number by dividing it by all numbers between 2 and @a/2. The little trick with @a/2 makes it twice as fast as without :-)

UPDATE: It turns out, that in fact much time can be saved by just dividing with all integers between 2 and sqrt(@2) so the code below is updated, and it now runs in 2 seconds :-)

Enjoy!

declare @b int
declare @c float
declare @d int

select @a = 10
select @b = 10000
select @c = @a
select @d = 0


while @a < @b 
begin

select @c = (convert(int, sqrt(@a)) ) + 1

while @c > 1
begin


if (select (@a/@c) - (convert(int, @a/@c) )) = 0
  select @d=@d+1
  if (select (@a/@c) - (convert(int, @a/@c) )) = 0
  break
select @c=@c-1
end
if (select @d) = 0
  print convert(varchar(10),@a) + ' is a prime number'
select @d = 0
select @a=@a+1
end

It is not the fastest prime number finder in the world, but I clocked it at 50 2 seconds to find all primes between 10 and 10000 and 1 minute and 17 seconds to find all primes between 10 and 100.000. Can you beat that with T-SQL? in that case, post the code in a comment !

SQLIntersection - Troubleshooting & Tune

Dag 3 inleddes själva konferensen med 3 olika spår för oss med SQL fokus. Att välja rätt session är ju inte helt lätt och de som varit på PASS Summit vet hur svårt det kan vara att välja och ibland blir det fel. En nyhet som testas här är också värdarna för de olika spåren som jag skrivit om tidigare och det var också ett lyft för sessionerna. Spåren för dag 3 var:

Design and Tune
Troubleshooting and Monitoring
2012 and Beyond

För mig inleddes dagen med "Performance Troubleshooting" av Brent Ozar. Tiden för varje session är inte lång, ca 1 timme och Brent valde denna gång att presentera tre av sina farvoritverktyg:

Som sagt tiden är knapp men en lysande presentation och Brent är i en klass för sig.

En annan bra talare är Paul Randal som drog "Making SQL Faster : No so Simple Things". Han valde att fokusera på Waits och gick igenom symptom och orsaken till några av de vanligaste som förekommer.

SQLIntersection - Statement Execution and Optimizing Stored Procedures

Dag två i ett kyligare Vegas fortsatte för mig med sessionen "Understanding Statement Execution and Optimizing Stored Procedures". Också den hållen av Kimberly Tripp. Dock var inte Paul Randal med och stöttade idag eftersom han bara sa tre ord igår :-). Idag har vi gått genom procedurcachen eller plan cache'n som man numera kallar den och hur man bäst utnyttjar detta utrymme, som för t.ex. SQL Server 2008+ och SQL Server 2005 SP2 med 16 GB tilldelat till SQL Server hela 4,2 GB går åt till plan cache'n. Då går det inte att fylla den med planer som bara används enstaka gånger. Mer om detta och hur man hittar dessa kan man läsa här.

Förstås pratade vi mycket om Ad hoc frågor kontra lagrade procedurer och när man skall använda dem och vilka fördelar/nackdelar det ger, t.ex. problemen som man kan få med "parameter sniffing och vilka alternativ man har att för att lösa nackdelarna.

Att kombinera OR och AND i sina SQL satser har säkert de flesta märkt är ingen lyckad kombination när det gäller prestanda för SQL Server. Exemplet nedan är säkert inte alltför ovanligt för många av oss och detta resulterar ofta i dåliga planer. En lösningen som i alla fall kan hjälpa en del är "Option Recompile" men ännu bättre är kombinera detta med dynamisk SQL.

(
 @Lastname varchar(30) = NULL,
 @Firstname varchar(30) = NULL,
 @member_no int = NULL
)

SELECT m.* 
FROM dbo.member AS m
WHERE (m.lastname LIKE @lastname OR @lastname IS NULL)
 AND (m.member_no = @member_no OR @member_no IS NULL)
 AND (m.firstname LIKE @firstname OR @firstname IS NULL)

Också dag två mycket bra och nu är också antalet deltagare betydligt flera.

SQL Intersection - Indexing Strategies that Work

I går så startade SQLIntersection som alltså går under samma paraply som DevIntersection. Dock var det enda sessionen igår Kimberly Tripps om "Indexing Strategies that Work: Covering - Concepts, Concerns, Costs". En heldag med index som visade hur viktigt det är att göra rätt urval och skapa rätt index och att också inkludera de kolumner man behöver för att undvika sk bookmark lookups. Kimberly visade med formler som verkar hålla när SQL Server väljer att göra en table/index scan istället för denna lookup som kostar rejält när det gäller prestanda. Detta kallar hon "Tipping Point" och det kan förvåna många att det vid väldigt få rader som en bookmark lookup lönar sig, under 1 %. Mer om detta kan man testa själv här. Sammanfattningsvis handlar det om att skapa rätt index och bara för att det går att indexera allt betyder det inte att man skall göra det. Dessutom använda de möjlighet som finns i de olika SQL Server versionerna:

Nonclustered index (alla versioner)
Indexed views (SQL Server 2000)
Included columns (SQL Server 2005)
Filtered indexes (SQL Server 2008)
Filtered statistics (SQL Server 2008)

En mycket bra start alltså på denna konferens som idag fortsätter med heldagssessioner.

Snart dags för SQLIntersection

Redan i morgon startar SQLIntersection som vi skrivit om tidigare och som man kan läsa mer om här, med två dagar heldagssessioner. Sedan fortsätter det med 3 fullspäckade sessionsdagar innan det avslutas med en heldagssession på fredag. Det är första gången som SQLIntersection hålls och det är idel bra talare. Skall också bli spännande att bl a se hur konceptet med värdar med värdar för de olika sessionerna fungerar. Kimberly Tripp, Brent Ozar och Aaron Bertrand är de som håller i olika spåren.

Mer om agendan hittar ni här.

SQL Server link tip

Today I stumbled over a nice list of documented and undocumented DBCC commands. I verified the content against SQL Server 2012, and unfortunately it seems that a lot of the output has been removed, even if the commands still exsist. The list can be found here, but PLEASE be careful, and don't use DBCC commands that you are not 100% familiar with, on your production systems!

Monitoring SQL Server, your own way

When you think about monitoring SQL Server instances, you probably often think about monitoring that the service is up, performance, security and such.

But just as important in many cases is to monitor some specific part of you most critical systems. For example, how many rows are in a particular table, if a specific job takes too long to run or if a certain process is blocked. That is something that you cannot do out of the box in most monitoring systems. You could of course write specific scripts for it, depending on what tool you use for monitoring. But there is one way that works with most if not all monitoring tools, and that is to use the user settable performance monitor counters.

You have 10 counters to use, and it's quite easy. all you do is execute a stored procedure and use the value you want to expose to the performance counter as a parameter:

-- Set the value of user counter 1 to 5
exec sp_user_counter1 5
--The performance counter will now show 5

More information here: http://msdn.microsoft.com/en-US/library/ms187480(v=sql.110).aspx

Ny uppdatering för SQL Server 2012 SP1

Sedan förra veckan finns en ny uppdatering för SQL Server 2012 SP1. Vi har nu kommit till uppdatering nummer 3 som alltså innehåller alla förbättringar sedan service pack 1.

Denna uppdatering innehåller ovanligt många rättningar, nästan 40 stycken. Nedan följer några av dessa:

FIX: Poor performance in SQL Server 2012 when you run a SQL Server trace
FIX: CPU spike when there is no load on a server after you install SQL Server 2012 on the server
FIX: Error when you open a tabular model file in SQL Server 2012

Cumulative update package 3 for SQL Server 2012 SP1

http://support.microsoft.com/kb/2812412

Som vanligt gäller det att alltid testa innan man gör förändringar i sin produktionsmiljö, men man bör alltid kontrollera vilka förbättringar som gjorts i dessa uppdateringar, och vem vill inte ha löst dessa problem som man kan ha i sin SQL Server miljö ?.

Mer SQL Server på RunAs Radio

Som vi skrivit tidigare så finns det utmärkta möjlighet att lära sig mer om SQL Server på denna informationskanal, som faktiskt inte enbart handlar om SQL Server. Som regel är varje session på dryga halvtimmen och senaste SQL Server sessionen är denna som förstås handlar mycket om SQL Server 2012:

Robert Cain Gets Us Started with Business Intelligence

Hela innehållet hittar ni här.

Hur svårt kan det vara?

Vi som jobbar med SQL Server älskar verkligen produkten, för det mesta. Men inte riktigt hela tiden. Det kan man ibland se på Connect till exempel. Connect är Microsofts website för feedback från kunder på olika produkter, till exempel SQL Server. Och även om vi förstår att fel finns i programvaror, och att det ibland ka ta tid att fixa, så är det så att ibland tar det orimligt lång tid.

Exempel: För nästa 5 år sedan begärdes en förbättring av informationen kopplad till felmeddelandet "String or binary data would be truncated", och det är det ärende som har flest röster idag på Connect. Men det är fortfarande inte löst (Läs mer här: https://connect.microsoft.com/SQLServer/feedback/details/339410/please-fix-the-string-or-binary-data-would-be-truncated-message-to-give-the-column-name)

Men jag tycker att Connect är ett bra initiaitv av Microsoft, och tittar man på antal lösta ärenden ("Korrigerade", men även "Korrigeras inte" och "Kan ej återskapas" räknas som lösta) så är det ca 18.600 styck vilket visar på ett stort engagemang både från oss kunder och från Microsoft :-)

Kortet som sätter fart på SQL Server

"Går företagets SQL Server-databas lite trögt? Då kan det kanske vara läge att piska upp farten med hjälp av OCZ:s nya accelerationskort." http://techworld.idg.se/2.2524/1.496539/kortet-som-satter-fart-pa-sql-server

Visst är det bra om man får fart på sin SQL Server miljö. Dock är ju fakta att man i de allra flesta fall kan få det även utan att uppgradera sin hårdvara. Det är rätt ovanligt att vi möter sådana miljöer där det enda som återstår är att uppgradera sin hårdvara. Skall hur som helst blir spännade följa detta kort :-)

SQL Server Edition Features

Har ni precis som jag ställt er följande frågor någon gång?

Tex:
Måste man ha Enterprise Edition för att köra MERGE kommandot?
Svar: Nej, den finns till och med i Express Edition

Hur många instanser kan man installera av SQL Server på en och samma hårdvara?
Svar: 50 st, gäller alla editions

Är Change Tracking en Enterprise Edition feature?
Svar: Nej, även den finns i alla editions

Så finner ni svaren på detta och mycket mer här:
http://msdn.microsoft.com/en-us/library/cc645993.aspx

Kanske har ni även haft funderingar på hur mycket SQL Server klarar av i olika avseenden?

Tex: Hur många kolumner kan jag ha i ett och samma SELECT statement?
Svar: 4096

Vad är max antal filer i en databas?
Svar: 32767

Vad är max antal parametrar i en Stored Procedure?
Svar: 2100

Så finner ni svaren på detta och mycket mer här:
http://msdn.microsoft.com/en-us/library/ms143432.aspx

Båda länkar gäller SQL Server 2012.

SQL Learning resources : MSBI Academy

Recently I found a nice learning resource for Microsoft BI tools : http://msbiacademy.com Here you will find a lot of videos that will cover how to do something that MS BI practitioners need to know. The videos are aproximate no more than 10 minutes each for a specific topic.

There is also a Windows 8 app that you can download from the Windows Store to view the content

The site is created by Rob Kerr. He is a SQL Server MVP and is passionate about helping people use information to make their work a lot easier. He has used Microsoft databases and development tools since he first wrote Microsoft BASIC code to store customer information for his family business at the age of 13.

Thank you Rob!

Microsoft SQL Server Data Tools - Business Intelligence for Visual Studio 2012

In the 5th of March 2013, Microsoft released Microsoft SQL Server Data Tools - Business Intelligence for Visual Studio 2012. Download it from : http://www.microsoft.com/en-us/download/details.aspx?id=36843
This will give you Microsoft SQL Server Business Intelligence projects for Analysis Services, Integration Services, and Reporting Services support in Visual Studio 2012.

If you like to know more about SQL server 2012, feel free to contact us at SQL Service.

Generate Insert Statements

Ok, i might be the last person on earth to know about this but here it goes:

The other day a customer approached me with a question: "Is there a way to generate insert statements, with the data included, for a specific table ?"
My immediate thought was that surely Management Studio incorporates this kind of functionality.

I started to right click on a table just to see what options there are.
Immediately i saw: Script Table as -> Insert To -> New Query Editor Window...
Alright here we go, another - soon to be, satisfied customer!
Well, not really...what i got was an insert statement with all the columns - INSERT INTO Table(Columns) VALUES(Columns), not the data.

So back to square one, regroup, rethink...

Next thing that came to mind was right click on the database -> Tasks -> Generate Scripts...

Another wizard starts. Here i chose to script a specific table and click next. In the next step in the wizard there is a button - "Advanced" which shows us the Advanced Scripting Options.
Here i finally found what i was looking for: In "Types of data to script" i can choose: "Schema and data" which was exactly what i was looking for.

I finish the wizard and script the result to a new query window. And there is was, exactly as i wanted. Insert statements for every row in the table WITH the data.

There we go, another happy customer!

Check instant file initialization

Som vi skrivit om tidigare så finns det möjlighet att slippa den tid det tar för datafilen att växa genom att skippa den sk nollutfyllnaden. Detta kan man läsa mer om i detta inlägg: http://www.sqlservice.se/sv/start/blogg/instant-file-initialization.aspx

Om man verkligen vill kontrollera om detta fungerar och om det är nödvändigt att göra några förändringar, dvs man är osäker om det fungerar med nuvarande inställningar är frågan "Hur vet man det". Jo, genom att slå på traceflaggorna 3004 och 3605, skapa en testdatabas, slå av traceflaggorna och ta bort databasen. Därefter kontrollerar man SQL Servers senaste errorlog och i början av densamme ser man hur detta fungerar.

Här ser man att den sk nollutfyllnaden av datafilen mdf insträffar och detta går alltså att undvika och som man förstås bör fixa av de orsaker som Janne skriver om i länken. I nästa bild ser vi att de gulmarkeraderna nu saknas. Däremot kan man inte undvika att nollutfyllnad sker av loggfilerna.

SQL koden för att testa detta är denna:

USE master; 

--Slå på traceflaggorna 3004 och 3605
DBCC TRACEON(3004, 3605, -1);

-- Skapa en testdatabas 
CREATE DATABASE TestDB ON  PRIMARY
	(NAME = N'TestDB', 
		FILENAME = N'C:\Temp\TestDB.mdf', SIZE = 5MB) 
	LOG ON( NAME = N'TestDB_log', 
		FILENAME = N'C:\Temp\TestDB_log.ldf', SIZE = 2MB) 
	
-- Slå av de två traceflaggorna
DBCC TRACEOFF(3004,3605,-1); 

--Ta bort databasen
DROP DATABASE TestDB;

Query the Server Error Log

If you would like to query the ERRORLOG with T-SQL you have the undocumented procedure SP_READERRORLOG. But as it's a procedure filteriung the result may be a bit hard.

By using a table variable it becomes much easier:

DECLARE @errorlog TABLE ( LogDate datetime, ProcessInfo varchar(max), LogText varchar(max) ) INSERT INTO @errorlog EXEC sp_readerrorlog SELECT * FROM @errorlog

Just add any where-clause and start finding the records you're interested in.

Några bra inställningar efter installation av SQL Server 2012

När man installerar SQL Server finns det några bra att göra inställningar.

Dels minimum och maximum memory, standardvärdet är 0 MB som minimum och 2147483647 MB, dvs 2 PB, som maximum. Jag brukar alltid reservera ett minimum och maximum baserat på mängden RAM servern har. Om min server har upp till 4GB RAM sätter jag 1024 MB som minimum och 3072 MB som maximum, dvs lämnar 1 GB till operativsystemet. 4-16 GB RAM, ja då sätter jag min till 2048 och max till 14336, dvs lämna 2 GB till operativsystemnet. Med 16GB eller mer så lämnar jag 4 GB RAM till operativsystemet. Om jag har fler instanser av SQL Server Database Engine eller andra tjänster måste jag minska max värdet för att inte överallockera fysiskt RAM-minne.

Maximum degree of parallellism är också ett värde som kan vara bra att konfigurera, generellt för ett OLTP-system kan man sätta MAXDOP till 1. Dvs stänga av parallellism, detta då OLTP operationer sällan drar nytta av parallellism, i ett OLTP-system kan till och med parallellism vara till nackdel. Detta beror dock på hur databasen är indexerad och hur frågorna ser ut. Upplever man oberäknelig locking p g a parallellism kan man prova att sätta detta värde till 1. I Data Warehouses däremot är parallellism ofta en fördel då det till största delen är läslås som är delade, och då riskerar man inte att man låser sig själv.

Nu finns det mer bakom dessa värden som man bör tänka på, det jag nämnt här är bara några bra att sätta värden på ett dedikerat och nyinstallerat system. Givetvis måste man mäta belastningen på servern och justera dessa och fler värden så att servern fungerar optimalt. Visste du att vi på SQL Service Nordic AB har flera bra produkter för att hjälpa Er hitta den mest optimala konfigurationen för Er databasserver och databas.

Ha det bra tills nästa gång!

/Mattias

Fun with SQL Server sys.messages

Sometimes I like to poke around inside SQL Server just for fun. Today I looked at the differences between SQL Server 2008R2 and SQL Server 2012 errormessages, located in sys.messages. I used the following query:

SELECT * FROM sys.messages WHERE language_id = 1033
AND message_id NOT IN(SELECT message_id FROM [localhost\sql2008r2].MASTER.sys.messages WHERE language_id = 1033)

That gave me 1616 rows back, but I suspect that some of these errormessages are not really new in SQL 2012, but rater have a new message_id. But, there are plenty of interesting messages left anyway, giving insight to functionality and maybe giving ideas. Many of the are related to SQL Azure, and are probably present because SQL Server and SQL Azure shares the same codebase.

Here are some that indicates that SQL Azure might have been called CloudDB internally:

(Columns are: message_id, language,severity, is_event_logged and text)

35412	1033	16	0	CloudDB Async Transport
35413	1033	16	0	CloudDB Async Transport Forwarder
40147	1033	16	0	Stored procedure '%.*ls' is only for CloudDB.
40166	1033	16	0	A CloudDB reconfiguration is going on and all new user transactions are aborted. 
40167	1033	21	1	A paired CloudDB fabric node failed and database %d must be shutdown. 
40572	1033	16	0	Cannot obtain primary partition lock for CloudDB auto partition upgrade.
40573	1033	16	0	Cannot upgrade CloudDB auto partitions in database '%.*ls' because the physical database is read only.

Here are some some more samples:

687 1033 16 0 Cannot compress a nchar or nvarchar column that has an odd number of bytes.
1482 1033 10 0 Database mirroring failed to get snapshot synchrinization lock.
1793 1033 16 0 Cannot federate a temporary table.
1795 1033 16 0 Nullable column '%.*ls' cannot be used to federate the table '%.*ls'.
1796 1033 16 0 Computed column '%.*ls' cannot be used to federate the table '%.*ls'.
1797 1033 16 0 Sparse column '%.*ls' cannot be used to federate the table '%.*ls'.
1798 1033 16 0 Federated tables cannot be created in a non-federated database.
1799 1033 16 0 Column '%.*ls' cannot be used to federate the table '%.*ls' because it does not match the federation key type.
1841 1033 16 0 CREATE DATABASE failed. CONTAINMENT clause cannot be used with the FOR ATTACH option.
4190 1033 16 0 PIVOT operator is not allowed in the recursive part of a recursive common table expression '%.*ls'.
4194 1033 15 0 RANGE is only supported with UNBOUNDED and CURRENT ROW window frame delimiters.
5287 1033 10 0 DBCC THROWERROR bypass exception. This is an informational message only. No user action is required.
5284 1033 16 0 The replicated index '%.*ls' (object ID %d) and one or more of its clones do not contain the same rows.
5283 1033 10 0 The Cross Rowset check on columnstore index object ID %d, index ID %d, partition ID %I64d. Drop and recreate the columnstore index.
5901 1033 16 0 One or more recovery units belonging to database '%.*ls' failed to generate a checkpoint. This is typically caused by lack of system resources such as disk or memory, or in some cases due to database corruption. Examine previous entries in the error log for more detailed information on this failure.
8658 1033 17 0 Cannot start the columnstore index build because it requires at least %I64d KB, while the maximum memory grant is limited to %I64d KB per query in workload group '%ls' (%ld) and resource pool '%ls' (%ld). Retry after modifying columnstore index to contain fewer columns, or after increasing the maximum memory grant limit with Resource Governor.
8659 1033 16 0 Cannot create the clustered index "%.*ls" on view "%.*ls" because for clustered indexes on aggregate views without GROUP BY, the only distribution option supported is DISTRIBUTION=NONE.
8674 1033 16 0 The query processor is unable to produce a plan. The table '%.*ls' is unavailable because the heap is corrupted. Take the database offline to rebuild the table and heap, and then run the query processor again.
8675 1033 17 1 A timeout occurred while waiting for remote memory resources to execute the query in resource pool '%ls' (%ld). Rerun the query.
8676 1033 16 0 Invalid plan.
10146 1033 16 0 Cannot create %S_MSG on the view '%.*ls' because it uses the SEMANTICSIMILARITYTABLE, SEMANTICKEYPHRASETABLE or SEMANTICSIMILARITYDETAILSTABLE function.
10746 1033 15 0 The FORCESCAN hint is specified simultaneously with the FORCESEEK hint. Remove one of the hints and resubmit the query.
10747 1033 15 0 The parameterized FORCESEEK hint cannot be simultaneously used with INDEX hints or a non-parameterized FORCESEEK hint on the same object. Use either INDEX hints and a non-parameterized FORCESEEK hint or use a parameterized FORCESEEK hint without INDEX hints for each table or view.
10748 1033 15 0 There are multiple FORCESEEK hints specified on the same table or view. Remove the extra FORCESEEK hints and resubmit the query.
10749 1033 15 0 The FORCESEEK hint cannot be used with index 0. Correct the index provided to the FORCESEEK hint and resubmit the query.
10750 1033 15 0 The FORCESCAN hint cannot be used with more than one INDEX hint. Remove the extra INDEX hints and resubmit the query.
12104 1033 15 0 ALTER DATABASE CURRENT failed because '%.*ls' is a system database. System databases cannot be altered by using the CURRENT keyword. Use the database name to alter a system database.
33426 1033 16 0 INSERT, UPDATE, DELETE, or MERGE to FileTable '%.*ls' is not allowed inside a trigger on a FileTable.
35217 1033 16 0 The thread pool for AlwaysOn Availability Groups was unable to start a new worker thread because there are not enough available worker threads. This may degrade AlwaysOn Availability Groups performance. Use the "max worker threads" configuration option to increase number of allowable threads.
35223 1033 16 0 Cannot add %d availability replica(s) to availability group '%.*ls'. The availability group already contains %d replica(s), and the maximum number of replicas supported in an availability group is %d.
35225 1033 16 0 Could not process the operation. The instance of SQL Server is running under WOW64 (Windows 32-bit on Windows 64-bit), which does not support AlwaysOn Availability Groups. Reinstall SQL Server in the native 64-bit edition, and re-enable AlwaysOn Availability Groups. Then, restart the SQL Server service, and retry the operation. For information about how to enable and disable AlwaysOn Availability Groups, see SQL Server Books Online.
35226 1033 16 0 Could not process the operation. AlwaysOn Availability Groups has not started because the instance of SQL Server is not running as a service. Restart the server instance as a service, and retry the operation.
35239 1033 16 0 The ALTER DATABASE SET HADR SUSPEND (or SET HADR RESUME) statement failed on database '%.*ls' of availability group '%.*ls''. Either the availability group does not contain the specified database, or the database has not joined the availability group, or the database has not yet started. Reenter the command after the database is online and has joined the availability group.'
35260 1033 16 0 During an attempted database recovery, an availability database manager was not found for database id %d with availability group ID %d and group database ID %ls. Recovery was terminated. The most likely cause of this error is that the availability group manager is not running, but the cause could be a metadata error. Ensure that the availability group manager and the WSFC cluster are started, and retry the recovery operation.
35261 1033 16 0 Attempt to perform an AlwaysOn Availability Groups operation on a system database, '%ls', failed. System databases are not supported by AlwaysOn Availability Groups.
35262 1033 17 1 Skipping the default startup of database '%.*ls' because the database belongs to an availability group (Group ID: %d). The database will be started by the availability group. This is an informational message only. No user action is required.
35263 1033 16 0 During the undo phase, a function call (%ls) to the primary replica returned an unexpected status (Code: %d). Check for a possible cause in the SQL Server error log for the primary replica. If an error occurred on the primary database, you might need to suspend the secondary database, fix the issue on the primary database, and then resume the database.
35264 1033 10 0 AlwaysOn Availability Groups data movement for database '%.*ls' has been suspended for the following reason: "%S_MSG" (Source ID %d; Source string: '%.*ls'). To resume data movement on the database, you will need to resume the database manually. For information about how to resume an availability database, see SQL Server Books Online.
35265 1033 10 0 AlwaysOn Availability Groups data movement for database '%.*ls' has been resumed. This is an informational message only. No user action is required.
35266 1033 10 0 AlwaysOn Availability Groups connection with %S_MSG database established for %S_MSG database '%.*ls' on the availability replica with Replica ID: {%.8x-%.4x-%.4x-%.2x%.2x-%.2x%.2x%.2x%.2x%.2x%.2x}. This is an informational message only. No user action is required.
35267 1033 10 0 AlwaysOn Availability Groups connection with %S_MSG database terminated for %S_MSG database '%.*ls' on the availability replica with Replica ID: {%.8x-%.4x-%.4x-%.2x%.2x-%.2x%.2x%.2x%.2x%.2x%.2x}. This is an informational message only. No user action is required.
35301 1033 15 0 CREATE INDEX statement failed because a columnstore index cannot be unique. Create the columnstore index without the UNIQUE keyword or create a unique index without the COLUMNSTORE keyword.
35302 1033 15 0 CREATE INDEX statement failed because specifying sort order (ASC or DESC) is not allowed when creating a columnstore index. Create the columnstore index without specifying a sort order.
35305 1033 15 0 CREATE INDEX statement failed because a columnstore index cannot be created on a view. Consider creating a columnstore index on the base table or creating an index without the COLUMNSTORE keyword on the view.
35307 1033 15 0 CREATE INDEX statement failed because column '%.*ls' on table '%.*ls' is a computed column and a columnstore index cannot be created on a computed column. Consider creating a nonclustered columnstore index on a subset of columns that does not include the column.
35308 1033 15 0 CREATE INDEX statement failed because a columnstore index cannot be a filtered index. Consider creating a columnstore index without the predicate filter.
35309 1033 15 0 CREATE INDEX statement failed because a columnstore index cannot be created on a sparse column. Consider creating a nonclustered columnstore index on a subset of columns that does not include any sparse columns.
35311 1033 15 0 CREATE INDEX statement failed because a columnstore index cannot have included columns. Create the columnstore index on the desired columns without specifying any included columns.
35312 1033 15 0 CREATE INDEX statement failed because a columnstore index cannot be created on a column with filestream data. Consider creating a nonclustered columnstore index on a subset of columns that does not include any columns with filestream data.
35313 1033 15 0 CREATE INDEX statement failed because specifying FILESTREAM_ON is not allowed when creating a columnstore index. Consider creating a columnstore index on columns without filestream data and omit the FILESTREAM_ON specification.
35314 1033 15 0 CREATE INDEX statement failed because a columnstore index cannot be created on a column set. Consider creating a nonclustered columnstore index on a subset of columns in the table that does not contain a column set or any sparse columns.
35315 1033 15 0 CREATE INDEX statement failed because a columnstore index cannot be created in this edition of SQL Server. See Books Online for more details on feature support in different SQL Server editions.
35316 1033 15 0 CREATE INDEX statement failed because a columnstore index must be partition-aligned with the base table. Create the columnstore index using the same partition function and same (or equivalent) partition scheme as the base table. If the base table is not partitioned, create a nonpartitioned columnstore index.
35317 1033 15 0 CREATE INDEX statement failed because specifying %S_MSG is not allowed when creating a columnstore index. Consider creating a columnstore index without specifying %S_MSG.
35318 1033 15 0 CREATE INDEX statement failed because the %S_MSG option is not allowed when creating a columnstore index. Create the columnstore index without specifying the %S_MSG option.
35320 1033 15 0 CREATE INDEX statement failed because specifying DATA_COMPRESSION is not allowed when creating a columnstore index. Consider creating a columnstore index without specifying DATA_COMPRESSION. Columnstore indexes are always compressed automatically.
35325 1033 15 0 ALTER TABLE statement failed because the definition of a column cannot be changed if the column is part of a columnstore index. Consider dropping the columnstore index, altering the column, then creating a new columnstore index.
35326 1033 15 0 ALTER INDEX statement failed because a columnstore index cannot be reorganized. Reorganization of a columnstore index is not necessary.
35327 1033 15 0 ALTER INDEX REBUILD statement failed because specifying %S_MSG is not allowed when rebuilding a columnstore index. Rebuild the columnstore index without specifying %S_MSG.
35328 1033 15 0 ALTER INDEX REBUILD statement failed because the %S_MSG option is not allowed when rebuilding a columnstore index. Rebuild the columnstore index without specifying the %S_MSG option.
35329 1033 15 0 ALTER INDEX REBUILD statement failed because specifying DATA_COMPRESSION is not allowed when rebuilding a columnstore index. Rebuild the columnstore index without specifying DATA_COMPRESSION. Columnstore indexes are always compressed automatically.
35330 1033 16 0 %S_MSG statement failed because data cannot be updated in a table with a columnstore index. Consider disabling the columnstore index before issuing the %S_MSG statement, then rebuilding the columnstore index after %S_MSG is complete.
35334 1033 15 0 DBCC DBREINDEX failed because specifying FILLFACTOR is not allowed when creating or rebuilding a columnstore index. Rebuild the columnstore index without specifying FILLFACTOR.
35336 1033 15 0 CREATE INDEX statement failed because specifying key list is missing when creating an index. Create the index with specifying key list .
35337 1033 16 0 UPDATE STATISTICS failed because statistics cannot be updated on a columnstore index. UPDATE STATISTICS is valid only when used with the STATS_STREAM option.
35338 1033 16 0 Clustered columnstore index is not supported.
35339 1033 16 0 Multiple nonclustered columnstore indexes are not supported.
35340 1033 16 0 Conversion between columnstore index and relational index is not supported.
35341 1033 16 0 CREATE INDEX statement failed. A columnstore index cannot include a decimal or numeric data type with a precision greater than 18. Reduce the precision of column '%.*ls' to 18 or omit column '%.*ls'.
35342 1033 16 0 CREATE INDEX statement failed. A columnstore index cannot include a datetimeoffset data type with a precision greater than 2. Reduce the precision of column '%.*ls' to 2 or omit column '%.*ls'.
35343 1033 15 0 CREATE INDEX statement failed. Column '%.*ls'has a data type that cannot participate in a columnstore index. Omit column '%.*ls'.
35344 1033 16 0 MERGE clause of ALTER PARTITION statement failed because two nonempty partitions containing a columnstore index cannot be merged. Consider disabling the columnstore index before issuing the ALTER PARTITION statement, then rebuilding the columnstore index after ALTER PARTITION is complete.
35345 1033 16 0 MERGE clause of ALTER PARTITION statement failed because two partitions on different filegroups cannot be merged if either partition contains columnstore index data. Consider disabling the columnstore index before issuing the ALTER PARTITION statement, then rebuilding the columnstore index after ALTER PARTITION is complete.
35346 1033 16 0 SPLIT clause of ALTER PARTITION statement failed because the partition is not empty. Only empty partitions can be split in when a columnstore index exists on the table. Consider disabling the columnstore index before issuing the ALTER PARTITION statement, then rebuilding the columnstore index after ALTER PARTITION is complete.
35347 1033 16 0 The stored procedure, sp_tableoption failed because a table with a nonclustered columnstore index cannot be altered to use vardecimal storage format. Consider dropping the columnstore index.
35348 1033 16 0 CREATE INDEX statement failed because table '%.*ls' uses vardecimal storage format. A columnstore index cannot be created on a table using vardecimal storage. Consider rebuilding the table without vardecimal storage.
35349 1033 16 0 TRUNCATE TABLE statement failed because table '%.*ls' has a columnstore index on it. A table with a columnstore index cannot be truncated. Consider dropping the columnstore index then truncating the table.
35350 1033 16 0 CREATE INDEX statement failed because a columnstore index on a partitioned table must be partition-aligned with the base table. Consider dropping the columnstore index before creating a new clustered index.
35351 1033 16 0 DROP INDEX statement failed because a columnstore index on a partitioned table must be partition-aligned with the base table (heap). Consider dropping the columnstore index before dropping a clustered index.
35352 1033 16 0 %S_MSG statement failed because the operation cannot be performed online on a table with a columnstore index. Perform the operation without specifying the ONLINE option or drop (or disable) the columnstore index before performing the operation using the ONLINE option.
35353 1033 16 0 %s cannot be enabled on a table with a columnstore index. Consider dropping columnstore index '%s' on table '%s'.
35354 1033 16 0 CREATE INDEX statement failed because a columnstore index cannot be created on a table enabled for %S_MSG. Consider disabling %S_MSG and then creating the columnstore index.
35355 1033 16 0 CREATE INDEX statement failed. Column '%.*ls' is either a primary key or a partitioning key that must be included, but a columnstore index cannot include a decimal or numeric data type with a precision greater than 18. Consider reducing the precision of column '%.*ls' to 18.
35356 1033 16 0 CREATE INDEX statement failed. Column '%.*ls' is either a primary key or a partitioning key that must be included, but a columnstore index cannot include a datetimeoffset data type with a precision greater than 2. Consider reducing the precision of column '%.*ls' to 2.
35357 1033 15 0 CREATE INDEX statement failed. Column '%.*ls' is either a primary key or a partitioning key that must be included, but '%.*ls'has a data type that cannot participate in a columnstore index.
40014 1033 16 0 Multiple databases can not be used in the same transaction.
40034 1033 16 0 CSN being added must be equal last CSN+1. The new CSN is (%d,%I64d), the current CSN is (%d,%I64d).
40131 1033 16 0 Partition key type '%.*ls' is not supported. Only BIGINT, UNIQUEIDENTIFIER, and VARBINARY(n) (0

SQL Server compression - don't loose it

If you are using the Enterprise Edition of SQL server 2008 or later, you have the option to use Data compression and it can be used to improve performance in some scenarios. It is easy to apply datacompression to an existing index. The script below rebuilds an existing index on Employee table in AdventureWorks:

ALTER INDEX [AK_Employee_rowguid] ON [HumanResources].[Employee] REBUILD PARTITION = ALL 
WITH (
	PAD_INDEX = OFF, 
	STATISTICS_NORECOMPUTE = OFF, 
	SORT_IN_TEMPDB = OFF, 
	IGNORE_DUP_KEY = OFF, 
	ONLINE = OFF, 
	ALLOW_ROW_LOCKS = ON, 
	ALLOW_PAGE_LOCKS = ON, 
	DATA_COMPRESSION = PAGE)

But when you have applied data compression, make sure you don't loose it by mistake. Lets say you wants to add another column to the index and you right click the index and klick the menu Script Index /Drop and Create to / New Query Window, and then you add your column to the create script and execute the query.

If you are unlucky the compression is lost. Why? Well it has to to with an option in Management Studio. Click the menu Tools / Options, scroll down to the "SQL Server object explorer" and look at the "scripting" options. The default setting for "Script Data Compression Options" is actually false! Change the setting to True and close the dialog.

/Håkan Winther
COO / Senior SQL Server consultant

Förslag och buggar för SQL Server i Microsoft Connect

Om du hittar en bugg eller kommer på en ide på hur SQL server kan bli ännu bättre så kan du logga in på http://connect.microsoft.com/ och registerara din ide. Dessutom så kan du även rösta på andras förslag eller buggrapporter. Ju fler röster ett förslag eller buggrapport får desto större är chansen att Microsoft gör något av ditt connect item.

Personligen har jag rapporterat 3 st, gå gärna in och rösta på dem:

https://connect.microsoft.com/SQLServer/feedback/details/691085/plan-handle-for-the-last-execution-in-missing-index-dmv-s

https://connect.microsoft.com/SQLServer/feedback/details/691081/add-sort-order-suggestions-to-missing-index-dmv

https://connect.microsoft.com/SQLServer/feedback/details/699153/window-for-new-index-should-contain-option-for-compression

/Håkan Winther
COO / Senior SQL server konsult
Twitter: @h_winther

Värdet av certifieringar

I rekryteringstider framförallt, men även till vardags, är certifiering på Microsoft SQL Server hett och viktigt. Vi på SQL Service tycker att certifiering är viktigt och alla våra konsulter har aktuella certifieringar på Microsoft SQL Server inklusive SQL Server 2012. Men vad betyder en certifiering?

Om man klarar ett certifieringsprov anses man kapabel att motsvara den kompetensrollen certifieringen motsvarar, vilket består av ett antal kompetensdomäner med både praktiska och teoretiska mätområden definerade av tillverkaren. Ja ja, men vad betyder då en certifiering?

Att inneha en certifiering tillsammans med erfarenhet från "verkligheten" är en riktig guldklimp i och med att du med certifieringen kan visa att du teoretiskt motsvarar tillverkarens krav på kompetens, och med erfarenheten kombinerat även kunna motsvara "verklighetens" krav på kompetens. Här på SQL Service har vi väl över hundra års samlad erfarenhet av SQL Server och vi är certifierade.

För att förklara certifieringarna börjar vi med ett enskilt certifieringsprov, en så kallad MCP, Microsoft Certified Professional. Inom SQL Server 2012 finns för närvarande nio examineringsprov varav två är uppgraderingsprov på tidigare certifiering. Klarar man ett prov är man således MCP. Genom kombinationer av enskilda prov uppnår man därefter olika kompetensområden/-profiler.

MCSA, Microsoft Certified Solution Associate, är grunden vilket är tänkt att vara en bred kompetensbas passande för juniora konsulter. Den innefattar produktöversikt, implementation, drift och underhåll av teknologien. För SQL Server blir det således "MCSA: SQL Server 2012" och tre enskilda certifieringar.

MCSE, Microsoft Certified Solution Expert, är påbyggnad av certifieringen MCSA och passar ypperligt för seniora konsulter. Här specialiserar man sig mer inom vissa teknologiska aspekter av produkten. Det innefattar bland annat mer detaljkännedom, djupare analyskunskap, vidare arkitekturella problemställningar och utveckling inom en smalare del av produkten. Inom Microsoft SQL Server 2012 finns det två huvudinriktningar, "MCSE: Data Platform" och "MCSE: Business Intelligence".

MCSE: Data Platform fokuserar mer på databasadministratörs och -utvecklarrollen och innefattar främst kompetenser inom Database Engine, OLTP, datalager, utveckling, prestanda och optimering.

MCSE: Business Intelligence har sitt fokus inom BI och innefattar teknologier som Integration Services, Analysis Services och Reprting Services samt Data Quality Services, Master Data Services, PowerPIVOT, PowerView med mera.

Tidigare genom åren har dessa certifieringar haft lite olika namn och förkortningar som MCDBA "Microsoft Certified Database Administrator", MCTS "Microsoft Certified Technology Specialist" och MCITP "Microsoft Certified Information Technology Professional". MCTS motsvarar i stort nivån för MCSA, och MCITP samt MCDBA motsvarar nivån MCSE.

För de som är riktigt hard-core finns det även en certifiering som heter Microsoft Certified Solutions Master, MCSM. För Microsoft SQL Server 2012 blir det således "MCSM: Data Platform", dock har dessa examineringar ej ännu färdigutvecklats. Tills vidare är det således dem motsvarande certifieringen Microsoft Certified Master, MCM, och då på Microsoft SQL Server 2008 som gäller, "MCM: SQL Server 2008". För att klara dessa examineringar måste man ha dokumenterad flerårig erfarenhet av produkten och extremt djupa kunskaper. Examineringen består av två delar, dels en teoretiskt test "Knowledge Exam" och dels en verklighetsbaserad labb "Lab Exam" där verkliga case simuleras och du handgripligen ska genomföra de bästa, mest rationella och mest kostnadseffektiva lösningarna på problemen. Man måste först klara det teoretiska testet och därefter vänta minst en månad för att testet ska rättas och poängsättas, därefter får man boka labben som övervakas manuellt. Klarar man sedan den är man del av en ytterst liten grupp världen över. Om du däremot missar ett av proven måste du vänta minst tre månader innan du får försöka igen.

Lite andra certifieringar och utmärkelser värda att nämna i sammanhanget är MCT, Microsoft Certified Trainer, som är ett krav att inneha för att få leverera officiella Microsoft-kurser. Detta är mer av en ackreditering snarare än en certifiering. För att få bli MCT måste man först och främst ha expertnivåcertifiering inom det produktområde man fokuserar på, sedan måste man inneha en tillbörlig certifiering inom pedagogik. Det här är en certifiering man måste förnya varje år och samtidigt bibehålla en tillräcklig hög nivå av nöjda kursdeltagare. När du går på en officiell Microsoft-kurs måste utbildaren vara dels MCT och dels certifierad, dvs om kursen har en motsvarande certifiering måste även utbildaren även klarat den examineringen. MVP, eller Microsoft Most Valuable Professional, är inte en certifiering utan en utmärkelse man kan tilldelas. Normalt brukar det innebära att man är ytterst exeptionell inom en viss del av en produkt, man bloggar om det, svarar på frågor på allehanda forum om det, man talar på konferenser och användarföreningsmöten om det, och om man gör det så bra och till den utsträckning att det utmärker sig över mängden så man blir nominerad till utmärkelsen och därefter en review av en board på Microsoft blir tilldelad utmärkelsen kan man känna sig hedrad av att tillhöra en liten skara.

Några av de certifieringar och utmärkelser du kan finna bland oss här på SQL Service:

MCDBA: SQL Server 2000
MCTS: SQL Server 2005 Database Administrator
MCITP: SQL Server 2005 Database Administrator
MCTS: SQL Server 2005 Database Developer
MCITP: SQL Server 2005 Database Developer
MCTS: SQL Server 2005 Business Intelligence
MCITP: SQL Server 2005 Business Intelligence
MCTS: SQL Server 2008
MCITP: SQL Server 2008 Data Platform
MCITP: SQL Server 2008 Database Developer
MCITP: SQL Server 2008 Business Intelligence
MCSA: SQL Server 2008
MCSA: SQL Server 2012
MCSE: Data Platform
MCSE: Business Intelligence
MCT
MVP: SQL Server

Har du frågor angående certifieringar eller kurser är du välkommen att höra av dig.

Ha det bara bäst så länge!

Mattias Lind

Consultant, Trainer, Mentor & Speaker

MVP | MCT | MCSE | MCSA | MCITP | MCTS | MCDBA

Ny förbättring av SQL Server 2012

Även för SQL Server 2012 finns nu en ny uppdatering i och med att en sk kumulativ upppdatering släppts. Dock gäller denna inte för SQL Server 2012 SP1. Vi har nu kommit till uppdatering nummer 6 som innehåller alla förbättringar sedan lanseringen av SQL Server 2012, men som sagt gäller inte denna för service pack 1 av SQL Server 2012.

Cumulative update package 6 for SQL Server 2012

Nya uppdateringar för SQL Server 2008 R2

Nu finns möjlighet att ladda ner nya förbättringar för SQL Server 2008 R2 i och med att nya sk kumulativa uppdateringar släppts för denna version.

SELECT @@VERSION

Cumulative update package 5 for SQL Server 2008 R2 SP2

Cumulative update package 11 for SQL Server 2008 R2 SP1

Som vanligt gäller det att alltid testa innan man gör förändringar i sin produktionsmiljö, men man bör alltid kontrollera vilka förbättringar som görs i dessa uppdateringar.

A SQL Azure tip a day (18) - My Laptop is faster than SQL AZURE ?!?

EDIT: Also read this blogpost: http://sqlservice.se/sv/start/blogg/sql-azure-followup.aspx , that gives more context to the findings in this post.

Today we will take a look at the INSERT speed of SQL Azure, compared to my laptop. So I did the following on both my HP ENVY i5 Laptop and 1 internal spinning disc and SQL Server 2008 R2, and my SQL Azure Web edition database.

I created 2 tables with clustered indexes:

CREATE TABLE [dbo].[TableTest]( [Int_Col] [int] IDENTITY(1,1) NOT NULL, [Varchar_Col] [varchar](50) NOT NULL, [Datetime_Col] [datetime] NOT NULL, [GUID_Col] [uniqueidentifier] NOT NULL )

ALTER TABLE [dbo].[TableTest] ADD  CONSTRAINT [DF_TableTest_Varchar_Col]  DEFAULT ('Varchar_Col') FOR [Varchar_Col] ALTER TABLE [dbo].[TableTest] ADD  CONSTRAINT [DF_TableTest_Datetime_Col]  DEFAULT (getdate()) FOR [Datetime_Col]

ALTER TABLE [dbo].[TableTest] ADD  CONSTRAINT [DF_TableTest_GUID_Col]  DEFAULT (newid()) FOR [GUID_Col]

GO

CREATE CLUSTERED INDEX [ix_tabletest] ON [dbo].[TableTest] ( [GUID_Col] ASC )

WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, SORT_IN_TEMPDB = OFF, IGNORE_DUP_KEY = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON)

GO

CREATE TABLE [dbo].[results]

( [GUID] [uniqueidentifier] NOT NULL, [test] [varchar](50) NULL, [starttime] [datetime2](7) NULL, [endtime] [datetime2](7) NULL, [rownr] [bigint] NULL, [Runtime_MS]  AS (datediff(millisecond,[starttime],[endtime])), [Rows_pr_ms]  AS (isnull(CONVERT([decimal],[rownr],0)/datediff(millisecond,[starttime],[endtime]),(0))) ) GO

CREATE CLUSTERED INDEX [ix_results] ON [dbo].[results] ( [GUID] ASC )WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, SORT_IN_TEMPDB = OFF, IGNORE_DUP_KEY = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) GO CREATE TABLE [dbo].[guidtbl]( [GUID] [uniqueidentifier] NOT NULL )

CREATE CLUSTERED INDEX [ix_guidtbl] ON [dbo].[guidtbl] ( [GUID] ASC )WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, SORT_IN_TEMPDB = OFF, IGNORE_DUP_KEY = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) GO

Then I created A stored proc:

create proc [dbo].[insert_test] @rows int as 

SET NOCOUNT ON 

SET STATISTICS IO OFF 

SET STATISTICS TIME OFF 

truncate table guidtbl 

insert guidtbl (GUID) Values (NEWID()) 

TRUNCATE TABLE [dbo].[TableTest] 

Declare @GUID uniqueidentifier 

select @GUID = guid from guidtbl 

Insert results ([GUID], test, starttime) values (@GUID, 'INSERT_Test', getdate()) 

declare @i int 

select @i = 0 while @i < @rows 

begin 

INSERT INTO [dbo].[TableTest] ([Varchar_Col] ,[Datetime_Col] ,[GUID_Col]) VALUES (default ,default ,default) 

select @i = @i + 1 

end 

Update results set endtime = getdate() where test = 'Insert_Test' and endtime IS NULL 

DECLARE @rownr int 

select @rownr =  count(*) from TableTest update results set rownr =  @rownr where test = 'Insert_Test' and rownr IS NULL

 GO

And then I executed it: exec dbo.insert_test 100000

The results? After a few testruns the results table looks like this on SQL AZURE: select * from results And the results table on my laptop: select * from results

The conclusion? My Laptop is faster than SQL Azure! Atleast when it comes to pure INSERT performance.

The reason? Obviously I can’t be 100% sure about why. But having repeated the test on several other servers, I have reached the following conclusion: The INSERT performance problems in SQL AZURE is likely caused by the underlying IO subsystem, particularly on the drive that holds the logfile, and by the fact that you have 3 redundant copies of your database. Using this script by Håkan Winther, I captured the following snapshots of what I am waiting for during the INSERT test: and The results I have collected so far on other physical servers shows that SAN connected servers have a hard time getting more than about 1 INSERT per Millisecond. And the cause is that we wait for WRITELOG for about 0.8 milliseconds per row. The average wait time for WRITELOG on internal disks (Even when running on just a single laptop disc) is about 0.1 to 0.2 Milliseconds. Does this mean that my Laptop always are faster than SQL AZURE? Stay tuned, more tests are coming up :-)

Aston Tate/Microsoft SQL Server 1.0 for OS/2

Är man riktigt insnöad på SQL Server är det givetvis intressant att veta hur det hela började. För min egen del var jag inte med helt från början, utan började med version 4.21. Tur då at det finns andra som var med, och har skrivit ned historien! Korta fakta i tabellform hittar du hos Microsoft i detta lilla dokument. Men mer intressant är att läsa om Ron Soukup och Kalen Delaney's resa tillsammans med SQL Server, eller "Aston Tate/Microsoft SQL Server 1.0 for OS/2" som den första versionen hette. Mer om dessa väldigt tidiga år hittar du i denna PDF på Kalen Delaney's site http://www.insidesqlserver.com/

Multiple instances of SQL Server - memory consideration

If you plan to run multiple instances of SQL server on the same server, you should plan on how you are going to share the memory between the instances. When you install a SQL server, you get some default settings and some of them are regarding memory. By defualt the "min memory server" setting is 0 and the "max memory setting" is unlimited. This is not a prefered setting in a single instance installation and it is even worse for multiple instance installations.

In a single instance installation, SQL server and Windows server will compete of the memory resources as SQL server wants to allocate all memory.

In a multiple instance installations, you'll get multiple instances that is competing of the memory resources and all of the SQL instances wants to allocate all memory (based on the workload of cource).

If you have more memory than the workload of every SQL server instance, you probably don't see any problems. If you don't have enough memory, 1 or more instances have to release the memory in favour of another instance. This could be acceptable if the performance is not important in any of the SQL server instances.

When a SQL server instance have to release the memory, a message is written to the SQL server log:

A significant part of sql server process memory has been paged out. This may result in a performance degradation. Duration: x seconds. Working set (KB): y, committed (KB): z, memory utilization: %.

If you see alot of this messages, your SQL server performance is suffering from memory deallocations.

To solve this, you should consider to change the max server memory setting of all the SQL server instances. It can be changed in the Server properties dialog or by using T-SQL, but has to be done on every SQL server instance.

Server properties

T-SQL

Open a new query window and write the following code to change your max server memory to a desired value and execute the code

sp_configure 'max server memory (MB)', '13000' -- change the value to your desired memory
RECONFIGURE

Håkan Winther
COO / SQL Server consultant
Twitter: @h_winther

SQL error message - Property Owner is not available for Database

If you get the “Property Owner is not available for Database” error message when you try to show the properties of a database (right click on a database and click the “properties” menu), you somehow lost the login that is the owner of the database. It could be the result of a database restore on another SQL server instance where the login is not created.

Run the following code to see if any owner properties of the database is missing a login

-- check to see if owner is "unknown" for any database
EXEC sp_helpdb

The problem is easy to fix, copy the following code into a new query window, and press CTRL + SHIFT + M to open the template parameter dialog. Enter the databasename and the login you are going to use.

-- fix the problem, press CTRL + SHIFT + M
-- and type your dbname and loginname in the dialog
-- and execute the code
USE <dbname, sysname,>
GO
EXEC sp_changedwowner '<loginname, sysname, sa>'

-- check to see if owner is "unknown" for any database
EXEC sp_helpdb

SSMS + ALTER TABLE

Jag använder SQL Server Management Studio dagligen för att utföra diverse saker i de databasmiljöer jag jobbar i. Nästan alltid går detta smärtfritt och den gör som jag förväntar mig att den skall göra.
Ibland blir dock resultatet inte helt till belåtenhet....som tex när man vill ändra en befintlig tabell.

Låt oss titta på ett exempel.
Vi skapar en ny tabell:

CREATE TABLE test( id int identity(1,1), col varchar(50));

Antag att vi nu vill ändra på kolumnlängden på "col" till VARCHAR(100). Om vi nu beslutar oss för att göra detta i Management Studio så öppnar vi tabellen i design läge, ändrar kolumnlängden och skriptar ut förändringen för att se vad Management Studio egentligen hittar på bakom kulisserna.

Följande skript uppenbarar sig:

/* To prevent any potential data loss issues, you should review this script in detail before running it outside the context of the database designer.*/

BEGIN TRANSACTION
SET QUOTED_IDENTIFIER ON
SET ARITHABORT ON
SET NUMERIC_ROUNDABORT OFF
SET CONCAT_NULL_YIELDS_NULL ON
SET ANSI_NULLS ON
SET ANSI_PADDING ON
SET ANSI_WARNINGS ON
COMMIT

BEGIN TRANSACTION
GO
CREATE TABLE dbo.Tmp_test ( id int NOT NULL IDENTITY (1, 1), col varchar(100) NULL ) ON [PRIMARY]
GO
ALTER TABLE dbo.Tmp_test SET (LOCK_ESCALATION = TABLE)
GO
SET IDENTITY_INSERT dbo.Tmp_test ON
GO
IF EXISTS(SELECT * FROM dbo.test) EXEC('INSERT INTO dbo.Tmp_test (id, col) SELECT id, col FROM dbo.test WITH (HOLDLOCK TABLOCKX)')
GO
SET IDENTITY_INSERT dbo.Tmp_test OFF
GO
DROP TABLE dbo.test
GO
EXECUTE sp_rename N'dbo.Tmp_test', N'test', 'OBJECT'
GO
COMMIT

Vi kan se att Management Studio först skapar en temporär tabell enl den nya definitionen, kopierar över allt data, tar bort den gamla tabellen och döper till sist om den nya tabellen till rätt namn.
Detta känns onekligen som en omväg, om vi hade gjort detta med TSQL istället hade det blivit något enklare:

ALTER TABLE test ALTER COLUMN Col VARCHAR(100);

Har detta då någon betydelse? Ja, om tabellen vi vill ändra på är stor så kan det bli väldigt mycket data som måste flyttas runt eller om tabellen vi vill ändra tex är replikerad så kommer Managment Studios variant inte att fungera eftersom det faktiskt droppar tabellen medan ALTER TABLE... fungerar alldeles utmärkt mot en replikerad tabell.

Jag vet att detta inte är något nytt beteende hos Management Studio men icke desto mindre kan det vara något att ha i åtanke innan man börjar ändra i sina tabeller via designläget.

Tips på böcker

Förutom att gå utbildningar och följa events finns ett gammalt sätt att lära sig mer om SQL Server. Nämligen att läsa böcker. Många bra böcker finns faktiskt att ladda ner gratis och det kan också vara ett bra sätt innan man eventuellt köper boken med riktigt papper. Dessutom finns det rätt många böcker om SQL Server 2012 som kan vara ett bra sätt att se vilka möjligheter och fördelar man har av denna senaste SQL Server version.

Några tips på länkar där man kan hitta dessa böcker hittar man nedan:

http://it-ebooks.info/tag/server/

http://www.red-gate.com/community/books/

Errors in the OLAP storage engine: A duplicate attribute key has been found when processing: Table: '', Column: '', Value: ''. The attribute is ''.

Alright, so you get this error when you process your dimension. You look carefully throug your data looking for duplicate values, and you find NOTHING!?! Recognize the situation?

I had a frustrating time last week trying to understand the reason for this (fairly straight forward) error message. I looked very carefully at the data rows and could see duplicates in my SELECT...GROUP BY statement, how is that even possible?! Well it turns out that the data set was in really poor condition. The strings (addresses from a web form) were not cleaned from strange characters, so I had strings with leading and following characters in tha range from 0x01 to 0x31 (mostly non printables; look in an ascii table), thank God for CAST(SUBSTRING(address,1,1) AS BINARY(2)) AND CAST(SUBSTRING(REVERSE(address),1,1 AS BINARY(2)). Now I am going to have a little chat with the web developers on how to verify web form data BEFORE shipping it off into the backend systems...

//Joakim

Antoher type of SQL server crash

Usually our blog posts are about how to improve SQL server, your skills and about different types of crashes, but this blog post is about another type of crash.

Do you remeber the Astroid game back in early -90? Well I do! You had a small space ship (shaped as a triangle) and you had to avoid and destroy asteroids, if you didn't make it you crashed. It didn't have any fancy graphics like modern games.

What has this to do with SQL server? Well, you probably heard about Red-Gate, and they have developed a product called Red-Gate Source Control, and someone at Red-Gate seemed to like the Asteroid game too much. Why do I think that? Well because someone have added the Asteroid game as an "easter egg" in the Source Control product!

If you have installed Red-Gate Source Control, you simply open the Source Control Gui, click the "Help" button, click "About SQL Source Control" and wait a couple of minutes!

Personally I think they should spend more time in fixing defects and adding requested featurs in the product instead of adding features no one have requested and no one is willing to pay for, but thats my opinion. I know Microsft added a Doom easter egg in one of the early Excel versions, but why? Well, at least the developers could laugh at their work. :)

/Håkan Winther

Optimera C:

En bra åtgärd enligt våra erfarenheter är att manuellt defragmentera c-disken, som normalt används för installation av SQL Server innan man installerar SQL Server. Dessutom bör man schemalägga så att defragmenteringen sker en gång per vecka för samma disk. Som vi ser av bilden nedan så blir man annars uppmanad att att göra detta efter en tid. Dock skall man inte göra detta för övriga diskar som används för SQL Servers data- och loggfiler.

Att schemalägga detta är väldigt enkelt, genom att först välja dag för defragmenteringen.

Därefter väljer man diskarna som skall defragmenteras och alltså enbart c: i detta fall.

SQL server 2012 sp1 - sys.dm_db_stats_properties

It's been a while since my last blog post, due to a terrible cold that have forced me to bed, but now it's time for another blog post!

In SQL server 2012 service pack 1 there is a new function that will give you more details about the statistics. As you probably already know, the statistics are very important for the performance in SQL server. It's used by the optimizer to create an efficient execution plan. The new function can tell you if the statistics needs to be updated or if the sample rate is low.

You can use code like this:

SELECT
	objectName		= obj.name,
	statsName		= [stat].[name],
	statsColumns	= colList.[NAMES],
	[stat].[auto_created],
	[stat].[user_created],
	[stat].[no_recompute],
	[stat].[has_filter],
	[stat].[filter_definition],
	[stat].[is_temporary],
	[sp].[last_updated],
	[sp].[rows],
	[sp].[rows_sampled],
	[sp].[steps],
	[sp].[unfiltered_rows],
	[sp].[modification_counter],
	sampleRate = 1.0 * sp.[rows_sampled] / sp.[rows]
FROM sys.objects AS obj
INNER JOIN sys.stats stat
	 ON stat.object_id = obj.object_id
CROSS APPLY(
	SELECT STUFF(col.NAME,1,1,'') 
	FROM (
		SELECT ',' + c.[name] 
		FROM sys.[stats_columns] AS sc 
		INNER JOIN sys.[columns] AS c
			ON [sc].[column_id] = [c].[column_id]
			AND [sc].[object_id] = [c].[object_id]
		WHERE 
			sc.[object_id] = stat.[object_id]
			AND sc.[stats_id] = stat.[stats_id]
		FOR XML PATH('')
		) AS col(NAME)
	) AS colList(NAMES)
OUTER APPLY sys.dm_db_stats_properties(stat.object_id, stat.stats_id) AS sp
WHERE
	obj.[is_ms_shipped] = 0;

If you missed my previous blog posts about statistics, you can find them here:

http://www.sqlservice.se/sv/start/blogg/sql-server-performance--death-by-bad-statistics.aspx
http://www.sqlservice.se/sv/start/blogg/sql-server-statistics--local-variables.aspx
http://www.sqlservice.se/sv/start/blogg/sql-server-statistics--memory-request.aspx
http://www.sqlservice.se/sv/start/blogg/sql-server-statistics--read-only-database.aspx
http://www.sqlservice.se/sv/start/blogg/sql-server-statistics--table-variables.aspx
http://www.sqlservice.se/sv/start/blogg/sql-server-statistics--multicolumn-statistics.aspx

Feel free to contact any of other SQL server consultants if you wants to know more about SQL server and statistics.

Regards

/Håkan Winther

Change tracking for the non enterprise licensee

Hi,

at the latest PASS conference i Seattle I took part in several sessions on change tracking, but was very disappointed that every single one was dedicated to the CDC technology of change tracking.

Even when I remarked that there is a easier AND cheaper solution available, the presenters did not seem to know about it. Thus, I had to hold "mini sessions" after the CDC sessions where I explained to some of the audience that Change Tracking (CT) is also available as a change tracking method. The advantage with this method is that it is available on all versions of SQL Server (whereas CDC does demand the Enterprise $$$ license). Also CT only tracks net changes to data, not the full state shifting that CDC tracks by reading tha transaction log. In the normal scenario where you want to UPDATE the changed data rows only (through a MERGE), you do not care about intermediate states of you data rows, and CDC could be considered an overkill for the output you need.

CT works just like adding that extra rowversion column but only you do not have to do it in the table itself, it is done through SQL Server hidden system tables, which means that you do not have to modify your (3rd party?) data model to make CT possible!! Very appealing indeed.

I will not present the details in CT here, just really emphasize that this solution exists, that it is available, and also that it is very easy to set up.

Read Books Online, you will be surprised!

/Joakim Nyström

Veckans filmtips!

Har du lite tid över ibland, till exempel när du sitter på tåget, eller när du krupit upp i soffan framför brasan en lördagskväll? Känner du för att titta på en riktigt bra film, som får dig att tänka efter och utvecklas en liten bit? Då skall du surfa in på http://www.sqlug.se/sv-se/videos.aspx och botanisera i en imponerande lista över inspelade högklassiga Microsoft SQL Server föreläsningar i SQLUG's regi. Är du en riktigt SQL Server nörd, så är kvällen räddad :-)

Är du medlem i SQLUG?

Bor du i Sverige? Jobbar du med Microsoft SQL Server? Då skall du självklart vara medlem i SQLUG, den Svenska användarföreningen för SQL Server! Medlemskap är gratis, liksom de ca 7-9 träffarna som arrangeras i Stockholm, Malmö och Göteborg varje år. Det är dessutom ett bra tillfälle att träffa likasinnade SQL Server nördar, och diskutera de stora viktiga frågorna i arbetslivet, som skillnaden mellan INNER och OUTER join, Table Scan och Index Seek eller varför inte HASH Join vs Nested Loop?

Bli medlem idag genom att registrera dig här!

DBCC CLEANTABLE

Antag att du har en tabell med bla en kolumn som är av variabel längd tex VARCHAR(), NVARCHAR(), VARBINARY osv...
Om man nu tar bort variabel längds kolumnen kan man förvänta sig att tabellen minskar i storlek.
Vi testar.

Skapa en tabell:
CREATE TABLE Test (ID INT IDENTITY(1,1), Col VARCHAR(MAX));

Vi fyller tabellen med data:
INSERT INTO Test(Col) VALUES(REPLICATE('A', 1000));
GO 1000

Vi undersöker hur stor tabellen blivit:
SELECT alloc_unit_type_desc, page_count, avg_page_space_used_in_percent, record_count
FROM sys.dm_db_index_physical_stats( DB_ID('SQLService'),OBJECT_ID(N'Test'),NULL,NULL,'Detailed');

Ovan kan vi se att tabellen är utspridd på 150 data pages med ca 84% fyllnadsgrad.

Vi tar nu bort kolumnen "Col" för att frigöra utrymme:
ALTER TABLE Test DROP COLUMN Col;

En ny titt på hur stor vår tabell är visar att det inte hänt någonting, tabellen upptar fortfarande ca 84% av alla data pages.

För att frigöra utrymmet måste man använda sig av DBCC CLEANTABLE.

Vi kör:
DBCC CLEANTABLE('DatabasNamn','Tabellnamn',0);

Om vi nu återigen kontrollerar hur fyllnadsgraden ser ut för vår tabell visar det sig att den gått ner till ca 1%, vi har således återfått utrymmet för den borttagna kolumnen.

Varför vänta till hösten ?

Som vi vet kommer SQL Pass Summit i år gå av stapeln i Charlotte, North Carolina under oktober. Om man inte kan vänta till dess finns under april ett bra tillfälle att lära sig ännu mer om SQL Server. I Las Vegas går nämligen SQLIntersection den 7/4 - 12/4 som är späckad med bra SQL Server talare som ni kan läsa lite mer om här. Mer information om SQLIntersection hittar ni här, och där gör man även registrering.

Till försvar av SQL Server Express!

Vi på SQL Service brukar gärna skriva och prata om fördelarna med Enterprise Edition av Microsoft SQL Server, bland annat när det gäller prestanda och tillgänglighet. Men idag tänkte jag göra tvärt om, genom att slå ett slag för SQL Server Express Edition. Varför? Av den enkla anledning att den har en stor fördel som inte de andra editions av SQL Server har: den är gratis. (Ladda ned Microsoft SQL Server 2012 Express Edition här http://www.microsoft.com/en-us/download/details.aspx?id=29062)

Så, varför använder vi inte SQL Server Express i alla lägen? Eller i alla fall oftare än vad som verkar vara fallet idag? Dels beror det givetvis på att viss funktionalitet är begränsad, men även till stor del kanske på vår egen okunnighet och brist på fantasi? De begränsningar Microsoft valt att sätta på Express Edition kan vi givetvis inte ändra på, men om vi känner till vilka de är kan vi hitta på andra lösningar, och i alla fall ha en möjlighet att utvärdera om Express Edition kan vara lösningen på några, eller kanske många, av de SQL Server plattformsval som vi gör.

Så, vad är då de viktigaste begränsningarna?

SQL Server Agent saknas

SQL Profiler saknas

CPU: Max 1 CPU socket, eller 4 core

Minne: Max 1 GB för Database Engine och 4 GB för Reporting Services

Databasstorlek: Max 10 GB

Men, det finns även en hel del som faktisk ÄR inkluderat i Express Edition, som du kanske inte kände till:

Full Text Search inklusive Semantic Search

Windows Server Core support

Du kan köra upp till 50 instanser av Express Edition på en server

Stöd för Contained Databases

Change Tracking

Dedicated Admin Connection

SysPrep Support

Powershell Support

CLR Integration

Filetable

Reporting Services

Management Studio

Stöd för Spatiala (Geografiska) data och Index

Extended Events

Workarounds för begränsningar

Problemet med den saknade SQL Server Agenten

Om man vill köra produktionsdatabaser i SQL Server Express Edition, vill man ju givetvis ta backuper, underhålla index och statistik samt köra DBCC checkdb. Alt detta kan man göra (Till exempel med Ola Hallengrens script Http://ola.hallengren.com ) men problemet är att avsaknad av SQL Server Agent gör det lite knepigare att schemalägga underhållet. Det finns flera olika lösningar på det, varav den enklaste är att schemalägga MCD script i Windows via Scheduled Tasks. Dessa script ropar då lämpligen på stored procedures via SQLCMD.exe. Ett elegantare sätt beskrivs här http://www.sqlteam.com/article/scheduling-jobs-in-sql-server-express och består i att schemalägga med hjälp av SQL Server Service Broker och Conversion Timers Det finns även en gratis utility på CodePlex, som shcemalägger backup och underhåll vid hjälp av sqlmaint.exe här: http://expressmaint.codeplex.com/

SQL Profiler då?

Givetvis vill man ibland titta in under huven även på SQL Server Express, men ingen SQL Profiler följer med. Det bästa är då om man faktiskt vill anända Profiler, är att helt enkelt använda Profiler från en annan installation av SQL Server Standard eller Enterprise till exempel. Men man kan faktiskt använda Extended Events, även om det kan vara lite klurigt att komma igång med. Och även DBCC INPUTBUFFER kan ju lösa vissa enkla uppgifter.

Jag hoppas att detta kan ge inspiration till att använda SQL Server för typer av uppgifter där du idag kanske använder MySQl, Access eller liknande produkter, till exempel på grund av priset. Vi på SQL Service hjälper dig givetvis gärna!

Mer information om SQL Server Express Edition (Och även de andra Editions):

Books Online for SQL Server 2012 http://msdn.microsoft.com/en-us/library/ms130214.aspx

Compute Capacity Limits by Edition of SQL Server http://msdn.microsoft.com/en-us/library/ms143760.aspx

Editions and Components of SQL Server 2012 http://msdn.microsoft.com/en-us/library/ms144275.aspx

Features Supported by the Editions of SQL Server 2012 http://msdn.microsoft.com/en-us/library/cc645993.aspx

Maximum Capacity Specifications for SQL Server http://msdn.microsoft.com/en-us/library/ms143432.aspx

Snart dags för 24 Hours of PASS

Som vi skrivit om tidigare kommer det att gå en BI konferens den 10-12/4 i Chicago. Inför den kommer det som inför vanliga PASS Summit finnas möjligt att få ett smakprov av de sessioner som kommer hållas på denna BI konferens. Detta kommer idag den 30/1 med start kl 14:00 av tolv sessioner. Dessa kommer sedan gå i repris och finnas tillgängliga 12 timmar senare. Mer information om detta och registreringen för att följa dessa sessioner gör man här.

Gratis utbildning under 24 timmar !

Passa på detta tillfälle att prova på Pluralsights utbildningar som man denna månad kan nyttja gratis under 24 timmar. För SQL Server så finns det för närvarande 24 kurser. Registrering gör man här, och observera att detta erbjudande endast gäller innan 31/1 -13.

SQL Server 2012 SP1 CU2 released

Recently, SQL Server 2012 Servicepack 1 Cumulative Update 2 was released. And unlike some CU's this one has quite som extra functionality in it, not just bugfixes. The goodies released are:

Sysprep support for almost all features and tools, wich I have written more about here

The option to backup and restore databases directly to and from Windows Azure Blob Storage, read more here

More info about SQL 2012 SP1 CU2 can be found here, but beware, it seems to be automatically "translated" into your local language, and can be quite hard on the eyes because of that :-)

Sysprep support in SQL Server 2012

If you install a lot of servers, you are probably aware of a tool called Sysprep, that is used to take an windows installation and remove all specific information related to servername, SID's and so on. That allows you to take a snapshot of that image, and replicate it to many servers, and only have to run a shourt setup to type in the information specific to the particular server you are installing. That saves a lot of time during installation.

It has been possible to "Sysprep" an installation of SQL Server for some time (Read more here), but not all features. Starting with SQL Server 2012 ServicePack 1 Cumulative Update 2, sysprep support in now extended to all features and tools. Just about the only thing that is not supported, is failover clustering.

The process starts with installing Windows (obviously), and then installing a slipstreamed SQL Server SP1 CU2. Slipstreaming is not done by means of the Product Update feature of the setup program (Read more here). But instead of doing a normal install, you go to the Advanced tab, and select "Image preparation of a stand-alone instance of SQL Server" That will install SQL Server binaries, but not do any configuration. Then you sysprep your server. Now you have a template that you can use and reuse. After installing the template on a server, and completing the Windows mini setup, you can move on to configure SQL Server. This is easily done by clicking on a shortcut in the Start menu specifically made for that purpose, and entering the configuration details.

If you install a lot of SQL Servers, this can save you quite a lot of time.

Read more about Sysprep of Microsoft SQL Server here and here

Nya uppdateringar för SQL Server 2008

Innan jul kom nya uppdateringar för SQL Server och nu är det dags igen. Denna gång för SQL Server 2008 och SP3. Vi har nu kommit till kumulativa uppdateringen nr 9 för den installationen, alltså enbart SQL Server 2008 SP3

Den hittar man nedan, och nu har man löst 9 fel t.ex.

FIX: Incorrect result is returned when you query an indexed view by using the NOEXPAND hint in SQL Server 2008

SQL Server 2008 Service Pack 3 Cumulative Update 9

Som vanligt gäller det att alltid testa innan man gör förändringar i sin produktionsmiljö, och då först t.ex. i sin testmiljö.

Certificate expiry date

If you have a Database Mirroring setup or use Service Broker you may use certificates for endpoint authentication.

To create a certificate run:
CREATE CERTIFICATE [SQLService] ENCRYPTION BY PASSWORD = 'YourStrongPassword' WITH SUBJECT = 'SQLService certified certificate'

When you run this a certificate is created.
If we query sys.certificates and take a look at what we created we can see the following:

select name, pvt_key_encryption_type_desc, start_date, expiry_date,is_active_for_begin_dialog from sys.certificates where name = 'SQLService'

What we can see here is that our certificate is created and that we have a start date and expiry date. Since i didn't set these when i created the certificate it's created with default values which is the same start date as when i created it and the expiry date is one year later.

It might come as a surprise when your certificate suddenly has expired and your endpoints stops working and your database mirroring stops, not a very pleasant feeling.

So one thing to keep in mind is that whenever you create a new certificate make sure you set the expiry date.

DAX in the BI Tabular Model

Det språk vi har att använda i SQL Server Data Tools och nya Tabular model projects heter som bekant DAX, Data Analysis Expressions. Sedan några dagar finns det möjlighet att ladda ner ett whitepaper samt gott om exempel på hur detta språk används.

Detta hittar man här:

http://www.microsoft.com/en-us/download/details.aspx?id=28572&utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+MicrosoftDownloadCenter+%28Microsoft+Download+Center%29#tm

The maximum system-generated unique value for a duplicate group was exceeded

Meddelandet nedan ser man inte så ofta, tack och lov. Dock har jag nu stött på det.

Msg 666, Level 16, State 2, The maximum system-generated unique value for a duplicate group was exceeded for index with partition ID 72057594604617728. Dropping and re-creating the index may resolve this; otherwise, use another clustering key.

Detta inträffade i en gigantisk tabell, partitionerad på period (år + månad). Det innebär ett klustrat index på i det här fallet enbart period, som förstås inte är ett unikt värde. Alltså måste SQL Server lägga på en sk Uniqueifier för att det klustrade indexet skall bli unikt.

Om detta kan man läsa mer här och som framgår där och från Books Online :

If the clustered index is not created with the UNIQUE property, the Database Engine automatically adds a 4-byte uniqueifier column to the table. When it is required, the Database Engine automatically adds a uniqueifier value to a row to make each key unique. This column and its values are used internally and cannot be seen or accessed by users.

Som framgått av länken ovan så finns det en maxgräns för 4 294 967 296 innan man skall få detta meddelandet. Frågan kommer då, "Har vi nått denna gräns och vilken partition är det egentligen som spökar ?".

Med hjälp av denna fråga ser man för vilken partition som vi nått maxgränsen :

 SELECT 
           p.partition_number AS [PartitionNumber],
           p.data_compression_desc AS [DataCompression],
           prv.value AS [RightBoundaryValue],
           fg.name AS [FileGroupName],
           CAST(p.rows AS float) AS [RowCount],
           p.object_id,
           p.partition_id,
           idx.name AS Index_name
           
FROM
           sys.tables AS tbl
           INNER JOIN sys.indexes AS idx ON 
		idx.object_id = tbl.object_id AND 
		idx.type_desc = 'CLUSTERED'
           INNER JOIN sys.partitions AS p ON 
		p.object_id=CAST(tbl.object_id AS int) AND 
		p.index_id=idx.index_id
           INNER JOIN sys.indexes AS indx ON 
		p.object_id = indx.object_id AND 
		p.index_id = indx.index_id
           LEFT OUTER JOIN sys.destination_data_spaces AS dds ON 
		dds.partition_scheme_id = indx.data_space_id and 
		dds.destination_id = p.partition_number
           LEFT OUTER JOIN sys.partition_schemes AS ps ON 
		ps.data_space_id = indx.data_space_id
           LEFT OUTER JOIN sys.partition_range_values AS prv ON 
		prv.boundary_id = p.partition_number and 
		prv.function_id = ps.function_id
           LEFT OUTER JOIN sys.filegroups AS fg ON  
		fg.data_space_id = dds.data_space_id or 
		fg.data_space_id = indx.data_space_id

Detta visar att vår felande partition innehåller ca 700 000 rader och är alltså långt från maxgränsen på 4 294 967 296.

Första testen för att fixa detta problem är att enbart bygga om den felande partitionen för att tjäna tid.

ALTER INDEX [indexnamn] ON [dbo].[tabellnamn] REBUILD PARTITION = partitionsnr

Detta hjälper inte.

Nästa test är att bygga om hela det klustrade indexet.

ALTER INDEX [indexnamn] ON [dbo].[tabellnamn] REBUILD PARTITION = ALL

Tyvärr hjälper inte detta heller.

Till slut kommer här lösningen, som innebär att man använder en temptabell för att flytta allt data från partitionen, tömma dessa i orginaltabellen för att till slut läsa tillbaka allt.

SELECT *
INTO tmp_201212
FROM Fact
WHERE Period = 201212
 
DELETE
FROM Fact
WHERE Period = 201212
 
INSERT INTO Fact
(...)
SELECT *
FROM tmp_201212

SQL Server performance - missing indexes

As you already know by now, indexes are very important for SQL server performance, and finding the best indexes can be hard and time consuming. There are some tools that can help you or make things even worse. Some of the tools you can use are included in the SQL server platform, like:

Database engine tuning advisor
Missing index DMV:s
Estimated / Actual Execution plan

They all have capabilities to give you suggestions of indexes, but they also have their issues. I will not describe these features in detail, but if you use these tools to implement all the suggested indexes you can even decrease the performance. They give you suggestions and you still have to test the performance before and after.

Tool	Benefit	Concern
Database Tuning advisor	Give you good suggestions	-Uses a lot of resources -Give you a lot of similar indexes
Missing indexes	Give you good suggestions based on execution plans from the cache	Give you a lot of similar indexes Gives you suggestion of indexes that already exists because one of the columns need a different sort order, but there is no suggestion of the sort order
Estimated or Actual Execution plan	Give you the suggestion of index of the query you are running right now	Doesn’t display all the missing indexes for the query and you have to implement the index and execute one more time to get the next suggestion. The index suggestion is not displayed for the actual statement that needs the index

There is a connect item for the missing index DMV, please vote for it at :

The problem with the estimated or actual execution plan is that you can only see one suggestion at the time and it’s not correlated with the statement.

In SQL server 2012 you can get all the missing indexes in the estimated or actual execution plan GUI, but not in SQL server 2008. BUT you can find all the missing indexes in the execution plan XML, just right click the exection plan and click the “Show Execution Plan XML” menu item, search the XML for MissingIndex and you’ll find all of them! It’s only a GUI issue, all the information is in the XML plan.

How can you use this information? Well, if you now how to write some XQueries you can actually list all the missing indexes with the SQL statement attached. With this list you can investigate your index based on the statement that needs it. You can actually query the cache for all execution plans that have missing index suggestions, but beware, it is a heavy query that can cause performance issues during the execution.

The best solution is to pick the worst performing queries from the cache by using the sys.dm_exec_procedure_stats DMV and store the result in a temp table with an XML index.

Using XML in SQL server can be tricky unless you are very skilled in XQuery and I would like to help you a little bit to get started. In the following code, I have removed some interesting statements for other interesting information in the XML plan.

/*

SELECT  top 10 OBJECT_NAME([ps].[object_id], [ps].[database_id]), DB_NAME(database_id), *
FROM    sys.dm_exec_procedure_stats ps
CROSS APPLY sys.dm_exec_query_plan(ps.plan_handle) qp
order by ps.[last_logical_reads] desc

*/

CREATE PROCEDURE DBO.[spCheckSP](@dbName sysname, @schemaName sysname, @procedureName sysname)
AS
  -- +----------------------------------------------------------------------------------------------------------------
  -- ! O b j e c t                                            [ADMIN].[spCheckSP}
  -- ! R e t u r n s                                          INT
  -- ! P a r a m e t e r s           Name, DataType, Description
  -- + =========================================================================================
  -- !                                                                                             @dbName                                           sysname
  -- !                                                                                             @schemaName                          sysname
  -- !                                                                                             @procedureName                       sysname
  -- + ---------------------------------------------------------------------------------------------------------------
  -- ! O b j e c t i v e    
  -- + ---------------------------------------------------------------------------------------------------------------
  -- !   S A M P L E
  -- !                                                                     EXEC [ADMIN].[spCheckSP] 'AdventureWorks2008R2', 'Sales', 'uspGetBillOfMaterials'
  -- + ---------------------------------------------------------------------------------------------------------------
  -- ! H i s t o r y                                                       Date                    Who         What
  -- +========== ===== =========================================================================
  -- !                                                                     2011-01-26  HAWI            Initial version ...
  -- + ---------------------------------------------------------------------------------------------------------------

SET NOCOUNT ON;
 

SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED
            DECLARE @objectName SYSNAME = @dbName + '.' + @schemaName + '.' + @procedureName
            SELECT ProcedureName = @objectName;
 

           SELECT
                         query_plan = CONVERT(XML,qp.query_plan),
                         ps.*
            INTO #tmpPlan
            FROM sys.dm_exec_procedure_stats ps
            CROSS APPLY sys.dm_exec_query_plan(ps.plan_handle) qp
            WHERE OBJECT_ID = OBJECT_ID(@objectName)
            AND database_id = DB_ID(@dbName);
 

            SELECT * FROM [#tmpPlan];
 

 

            ----------------------------------------------------------------------------------------------------------------
            -- get missing index stats
            ----------------------------------------------------------------------------------------------------------------
            WITH XMLNAMESPACES (DEFAULT 'http://schemas.microsoft.com/sqlserver/2004/07/showplan')
            ,cteMissingIndexes
            AS (
                          SELECT tp.query_plan --, cp.usecounts
                          FROM #tmpPlan tp  
                          WHERE tp.query_plan.exist('//MissingIndex')=1
            )
            SELECT
                         databaseName             = stmt.value('(.//MissingIndex/@Database)[1]', 'sysname'),
                         [schemaName]             = stmt.value('(.//MissingIndex/@Schema)[1]', 'sysname'),
                         [tableName]                          = stmt.value('(.//MissingIndex/@Table)[1]', 'sysname'),
                         sql_text                                          = stmt.value('(@StatementText)[1]', 'VARCHAR(4000)'),
                         impact                                            = stmt.value('(.//MissingIndexGroup/@Impact)[1]', 'FLOAT'),
                         stmt.query('for $group in .//ColumnGroup
                                       for $column in $group/Column
                                       where $group/@Usage="EQUALITY"
                                       return string($column/@Name)
                                       ').value('.', 'varchar(max)') AS equality_columns
                          ,stmt.query('for $group in .//ColumnGroup
                                       for $column in $group/Column
                                       where $group/@Usage="INEQUALITY"
                                       return string($column/@Name)
                                       ').value('.', 'varchar(max)') AS inequality_columns
                          ,stmt.query('for $group in .//ColumnGroup
                                       for $column in $group/Column
                                       where $group/@Usage="INCLUDE"
                                       return string($column/@Name)
                                       ').value('.', 'varchar(max)') AS include_columns
                          ,pmi.query_plan
            FROM cteMissingIndexes pmi
                          CROSS APPLY pmi.query_plan.nodes('//StmtSimple') AS qp(stmt)
            WHERE stmt.exist('.//MissingIndex/ColumnGroup[@Usage="EQUALITY"]')=1 OR stmt.exist('.//MissingIndex/ColumnGroup[@Usage="INEQUALITY"]')=1
            UNION ALL
            SELECT
                         databaseName             = stmt.value('(.//MissingIndex/@Database)[1]', 'sysname'),
                         [schemaName]             = stmt.value('(.//MissingIndex/@Schema)[1]', 'sysname'),
                         [tableName]                          = stmt.value('(.//MissingIndex/@Table)[1]', 'sysname'),
                         sql_text                                          = stmt.value('(@StatementText)[1]', 'VARCHAR(4000)'),
                         impact                                            = stmt.value('(.//MissingIndexGroup/@Impact)[1]', 'FLOAT'),
                         stmt.query('for $group in .//ColumnGroup
                                       for $column in $group/Column
                                       where $group/@Usage="EQUALITY"
                                       return string($column/@Name)
                                       ').value('.', 'varchar(max)') AS equality_columns
                          ,stmt.query('for $group in .//ColumnGroup
                                       for $column in $group/Column
                                       where $group/@Usage="INEQUALITY"
                                       return string($column/@Name)
                                       ').value('.', 'varchar(max)') AS inequality_columns
                          ,stmt.query('for $group in .//ColumnGroup
                                       for $column in $group/Column
                                       where $group/@Usage="INCLUDE"
                                       return string($column/@Name)
                                       ').value('.', 'varchar(max)') AS include_columns
                          ,pmi.query_plan
            FROM cteMissingIndexes pmi
                          CROSS APPLY pmi.query_plan.nodes('//StmtCond') AS qp(stmt)
            WHERE stmt.exist('.//MissingIndex/ColumnGroup[@Usage="EQUALITY"]')=1 OR stmt.exist('.//MissingIndex/ColumnGroup[@Usage="INEQUALITY"]')=1;

As you can see, you need to query two different nodes (StmtSimple and StmtCond) to get all the missing indexes. The result might look something like this when you pass the name of a stored procedure into this procedure I gave you.

In this case, I have to statements that need an index each and I can investigate the query to see if I need to change something in the query or if I should create the index. The Impact is an estimate on how many percent improvement the index would give you, but it should be handled as a guess based and it is based on statistics. (read my other blog posts about statistics to understand why this not to be trusted.)

If you give me positive feedback (on twitter or as a comment) of the blog post, I’ll consider to post some other blog posts with other interesting parts of the XML plan and queries to extract it.

/Håkan Winther
twitter: @h_winther

New update for Red-Gate SQL Source Control

Red-Gate released a new update for SQL Source Control with some improvements.

New in SQL Source Control 3.1.0:

Shared Model Improvements. A more reliable and less resource-intensive method for giving the username for changes in the shared model.
Support for TFS 2012, including Team Foundation Service. Link databases to TFS 2012 servers, including those hosted at tfs.visualstudio.com (formerly tfspreview.com).
Support for Vault 6. Link databases to Vault 6 Standard and Vault 6 Pro servers.
Commit and Get Latest database comparision options.
Bug fixes.

The update can be downloaded from http://www.red-gate.com/updatecontrols/details?etc=627127226&guid=d13a9ba7-c46d-491f-9aad-69ff2fbc046b&update=463 or from inside the SQL Source Contol GUI.

Free SQL Server tablediff tool

Sometimes you need to compare the schema or contents of two tables. There are many good tools for that available, but you might be a little surprised to find out that there is actually a free tool for that included with Microsoft SQL Server. It is command line based, and the file to run is called Tablediff.exe. It is located in the C:\Program Files\Microsoft SQL Server\110\COM\ folder (For SQL Server 2012 that is).

Basically it can compare 2 tables, both the schema and the data. And it can log errors to file or table, and even give you a SQL Server scriptfile that you can run on the destination database to make the changes needed for the 2 tables to be identical if any differences should be found.

A simple syntax example, that compares the sysjobshistory table in MSDB between SQLSERVER1 and SQLSERVER2 SQL Server instances. It does not specify any login information, so it will run with the Windows account of the logged on account execution it. And if differences are found, a script will be created in c:\temp\tablediff.sql that will make the destination database identical to the source database:

"C:\Program Files\Microsoft SQL Server\110\COM\tablediff.exe" -sourceserver SQLSERVER1 -sourcedatabase msdb -sourceschema dbo -sourcetable sysjobhistory -destinationserver SQLSERVER2 -destinationdatabase msdb -destinationschema dbo -destinationtable sysjobhistory -f c:\temp\tablediff.sql

It can for example be used to check for differences in replicated tables, but that only works if you replicate all columns or else the schemas of the two tables are so different that you get an error.

The full documentation of Tablediff.exe can be found here

Analyze Query in Database Engine Tuning Advisor

Ett av verktygen som länge har följt med till SQL Server är "Database Tuning Advisor" eller DTA som man oftare säger. Det vanligaste sätter man använder DTA på är att först skapa en tracefil och sedan använda denna, för att i slutändan få en lista på rekommendationer samt skript genererade. Det avslöjar sig ganska snabbt om man har försökt använda detta verktyg för att optimera sin miljö eftersom alla nya ändringar får en viss namnstandard som vi kommer se längre ned.

Förutom en tracefil går det också att markera en sql-fråga, klicka höger mus och sedan välja menyalternativet "Analyze Query in Database Engine Tuning Advisor" för att använda DTA.

Tyvärr är inte detta verktyg vidare smart och kan ställa till det rejält, som jag visar av detta exempel.

Jag har en befintlig fråga som returnerar 201 rader och ger detta resultat:

Table 'Fact_Demo'. Scan count 4, logical reads 53393 ... ...

SQL Server Execution Times: CPU time = 890 ms, elapsed time = 977 ms.

DTA ger rekommendationen att skapa ett nytt index samt en mängd uppdatering av statistiken för tabellen ovan dvs Fact_Demo.

CREATE NONCLUSTERED INDEX [_dta_index_Fact__demo_10_1655676946__K1_K11_K13_K3_K2_K19_K10_

K17_K4_K18_K14_K15_K20_K23_24_25_26] ON [dbo].[Fact_demo] ( [Col1] ASC, [Col2] ASC, [Col3] ASC, [Col4] ASC, [Col5] ASC, [Col6] ASC, [Col7] ASC, [Col8] ASC, [Col9] ASC, [Col10] ASC, [Col11] ASC, [Col12] ASC, [Col13] ASC, [Col14] ASC ) INCLUDE ( [Col15], [Col16], [Col17] ) WITH (SORT_IN_TEMPDB = OFF, IGNORE_DUP_KEY = OFF, DROP_EXISTING = OFF, ONLINE = OFF) ON [Demo]

Efter ha implementerat alla ändringar som DTA föreslår så får jag nu detta resultat när jag kör frågan igen:

Table 'Fact_Demo'. Scan count 406, logical reads 158390 ... ...

SQL Server Execution Times: CPU time = 60466 ms, elapsed time = 64033 ms.

Detta innebär en klar försämring på ungefär 65 gånger efter ha litat blint på detta verktyg och inte riktigt vad man ville :-).

Bättre är då att lära sig om hur man optimerar sin miljö istället för att lita blint sådana här verktyg och ett sätt ätt göra detta är förstås att kontakta oss.

Vi ser alltför ofta nämligen en mängd index med namn som börjar med "_dta_index..." och dessa är troligen inte de mest optimala som vi har sett av exemplet ovan.

SQL Server certifieringar

Snart är det för sent att certfiera sig på SQL Server 2008. Den 31/7 2013 upphör nämligen möjligheten att ta nedanstående certfieringar, så det är hög tid att redan nu börja planera för detta om man har detta som mål, och det har vi förstås på SQL Service.

Microsoft Certified Technology Specialist (MCTS):

MCTS: 70-432 Implementation and Maintenance
MCTS: 70-433 Database Development
MCTS: 70-448 Business Intelligence Development and Maintenance

Microsoft Certified IT Professional (MCITP)

MCITP: Database Administrator 2008

PRO: 70-450 Designing, Optimizing and Maintaining a Database Server Infrastructure Using Microsoft SQL Server 2008

MCITP: Database Developer 2008

PRO: 70-451 Designing Database Solutions and Data Access Using Microsoft SQL Server 2008

MCITP: Business Intelligence Developer 2008

PRO: 70-452 Designing a Business Intelligence Infrastructure Using Microsoft SQL Server 2008

Databaser i SSMS Object Explorer

Antag att du har ett databashotell med ett flertal olika kunder. I detta scenario vill man säkerligen begränsa rättigheterna för de olika kunderna så att de bara har tillgång till sin egen databas.
Man kan skapa login för användaren och tilldela behörighet i de databaser som är aktuella. Detta fungerar fint, användaren kan logga in i Management Studio och kommer bara åt just de databaser som där vi tilldelat rättigheter.

Men användaren kan ju fortfarande se alla andra databaser i Management Studio Object Explorer, hur åtgärdar vi det?
I ett databashotell med många olika kunder kanske man inte vill visa tex hur många databaser som finns eller namnen på de andra databaserna etc.

För att begränsa vad en användare kan se i Management Studio Object Explorer kan man köra följande:
Antag att jag har en databas som heter SQLService och ett login som heter SQLService med begränsade rättigheter.

DENY VIEW ANY DATABASE TO [SQLService];

Om jag nu loggar in i Management Studio med mitt login (SQLService) och expanderar databasträdet kan jag inte se någon databas, bara systemdatabaserna master och tempdb.
EX:

Trots att jag har behörighet i databasen kan jag alltså inte se den. Provar nu att sätta min användare som databasägare:

ALTER AUTHORIZATION ON DATABASE::SQLService TO SQLService;

Nu kan jag se min egen databas och ingen annan.
EX:

Denna lösning är väl inte helt hundraprocentig, att sätta om databasägare till något annat än sa kanske inte är önskvärt ur alla synvinklar. Man hade hoppats på att detta kunde var implementerat lite bättre, finns även ett connect item anslaget av vår Svenske hjälte Erland Sommarskog:

http://connect.microsoft.com/SQL/feedback/ViewFeedback.aspx?FeedbackID=273830

SQL Server - the curse of heaps

A HEAP in SQL Server is a table without a clustered index, and in this blog post I'll show you the curse of heaps. Run the code below and take a look at the record_count and page_count for each result:

-- create a table with a large char column to create as many pages as records, just for the demonstration
CREATE TABLE dbo.HeapCurse(id INT IDENTITY(1,1), BigChar CHAR(4096));

SELECT 'CREATED', ips.[record_count], ips.[page_count] ,[ips].[avg_record_size_in_bytes]
FROM sys.dm_db_index_physical_stats(DB_ID(), OBJECT_ID('HeapCurse'), NULL, NULL, 'DETAILED') ips;

INSERT INTO dbo.HeapCurse (BigChar)
SELECT TOP 1000 'Håkan Winther'
FROM sys.columns c1 CROSS APPLY sys.columns c2;

SELECT 'INSERTED', ips.[record_count], ips.[page_count],[ips].[avg_record_size_in_bytes]
FROM sys.dm_db_index_physical_stats(DB_ID(), OBJECT_ID('HeapCurse'), NULL, NULL, 'DETAILED') ips;

DELETE FROM dbo.[HeapCurse];

SELECT 'DELETED', ips.[record_count], ips.[page_count], [ips].[avg_record_size_in_bytes]
FROM sys.dm_db_index_physical_stats(DB_ID(), OBJECT_ID('HeapCurse'), NULL, NULL, 'DETAILED') ips;

INSERT INTO dbo.HeapCurse (BigChar)
SELECT TOP 1000 'Håkan Winther'
FROM sys.columns c1 CROSS APPLY sys.columns c2;

DELETE FROM dbo.[HeapCurse] WITH(TABLOCK);

SELECT 'DELETED WITH TABLOCK', ips.[record_count], ips.[page_count], [ips].[avg_record_size_in_bytes]
FROM sys.dm_db_index_physical_stats(DB_ID(), OBJECT_ID('HeapCurse'), NULL, NULL, 'DETAILED') ips;

INSERT INTO dbo.HeapCurse (BigChar)
SELECT TOP 1000 'Håkan Winther'
FROM sys.columns c1 CROSS APPLY sys.columns c2;

TRUNCATE TABLE dbo.[HeapCurse];

SELECT 'TRUNCATED', ips.[record_count], ips.[page_count], [ips].[avg_record_size_in_bytes]
FROM sys.dm_db_index_physical_stats(DB_ID(), OBJECT_ID('HeapCurse'), NULL, NULL, 'DETAILED') ips;

DROP TABLE DBO.[HeapCurse];

Did you expect this result? As you can see in this results, the pages in the heap is not deallocated when you delete the records, and they can't be reused by another table. This results in 8kb pages that are like "living dead" (Zombies), they will stay there in the table and haunt your storage solution. In this case, I lost 8192kb space until I finally killed the Zombies.

As you could see, by using the TABLOCK hint when you deleted the records most of the pages are deallocated, but not all of them. To really deallocate all pages, you need use one of the following methods:

truncate the table
create a clustered index and then drop the index

The second option is more time consuming, but you don't need to delete all records.

Of course, the best option is to create a clustered index and keep it, but if you really think you have a good argument for using a HEAP, drop the clustered index.

/Håkan Winther

SQL Server statistics - local variables

If you have been following my blog serie about SQL server statistics, you have seen how statistics is used by the sql optimizer to create an execution plan. When the statistics is used in the wrong way, you'll end up with a bad execution plan.

This blog post is about another scenario when the statistics is not used correct. You can try this code in the AdventureWorks database:

SET STATISTICS IO ON;

SELECT
soh.[SalesOrderID],
[sod].[SalesOrderID],
[sod].[SalesOrderDetailID],
[sod].[CarrierTrackingNumber],
[sod].[OrderQty],
[sod].[ProductID],
[sod].[SpecialOfferID]
FROM [Sales].[SalesOrderHeader] AS soh
INNER JOIN [Sales].[SalesOrderDetail] AS sod
ON [soh].[SalesOrderID]=[sod].[SalesOrderID]
WHERE soh.OrderDate='2008-07-31'

DECLARE @orderDate DATE='2008-07-31'

SET STATISTICS IO OFF;

If you look at the execution plan for these queries, they look exactly the same, but the estimated cost for the first one is higher than the second one. BUT if you look closer, you'll see that there is a difference in "estimated number of records". In the first execution plan actual and estimated number of records are equal, but not in the second execution plan where estimated are less than actual.

Is this a problem? Well.... YES it is! If the table would have been big, you might have got a bad execution plan and SQL engine wouldn't have aquired enough memory for the query.

Is the first query actually more expensive than the second one? In this case, no. The cost is based on the estimated number of records and the first one did a much better estimate than the second on.

Why is the estimated incorrect in the second query? Values of local variables are not known in compile time when the execution plan is created, only in runtime and that leaves SQL server guessing.

24 Hours of PASS

Som vi skrivit om tidigare kommer det att gå en BI konferens den 10-12/4 i Chicago. Inför den kommer det som inför vanliga PASS Summit finnas möjligt att få ett smakprov av de sessioner som kommer hållas på denna BI konferens. Detta kommer ske den 30/1 med start kl 14:00 av tolv sessioner. Dessa kommer sedan gå i repris och finnas tillgängliga 12 timmar senare.

Allting startar med Alberto Ferrari och "PowerPivot for Excel 2013 in Action".

Mer information hittar ni här: http://www.24hoursofpass.com/

Byta databasnamn

Att namnge sin databas på ett vettigt sätt är självklart för de flesta. Det underlättar. Dock så kan man ibland behöva ändra namnet av olika anledningar, inget konstigt med det.

Att ändra namn på databasen är inte svårt, bara att använda sig av sp_renamedb.

Ex: EXEC master..sp_renamedb 'GammaltNamn','NyttNamn'

Databasen har nu fått ett nytt namn och allt är frid och fröjd...eller? Nej, vi har bara ändrat namnet på själva databasen inte dess fysiska filnamn. Varför är detta viktigt, är det viktigt...?

Jag tycker nog att man inte bör slarva med detta. För en tid sedan var jag hos en kund och flyttade en massa databaser från en server till en annan. Det visade sig rätt snabbt att man döpt om de flesta av databaserna men inte tagit hand om de fysiska filnamnen. Nu var det så att det redan fanns databaser på min målserver med samma fysiska filnamn som de databaser jag höll på att flytta vilket resulterade i att min restore inte gick igenom pga att filnamnen var upptagna.

Om man hade tagit hand om filnamnen samtidigt som man döpte om databaserna hade detta inte varit ett problem. Detta gäller även om man tex gör restore på en databas med ett nytt namn.

Att ändra de fysiska filnamnen är inte heller svårt.

Ex:
ALTER DATABASE [DatabasNamn] MODIFY FILE (NAME=N'GammaltNamn', FILENAME=N'NyttNamn')
GO
ALTER DATABASE [DatabasNamn] MODIFY FILE (NAME=N'GammaltNamn_log', FILENAME=N'NyttNamn_log')
GO

Efter detta måste man ta databasen offline, döpa om filerna, och sedan ta databasen online igen.

Edit:
Här blev det en liten tankevurpa av mig. Precis som Thomas skriver i sin kommentar så kan man visst ha samma logiska filnamn på databaserna, jag menade såklart de Fysiska filnamnen, inget annat! Rätt skall vara rätt. Inlägget är nu ändrat för att spegla detta.

New conference series from PASS!

If you haven´t noticed already, you BI people out there in the wild should really take a look at the PASS organizations new Business Intelligence conference series (to be?). It is called PASS Business Analytics Conference and it will premiere in Chicago already in April (10-12th). For those of you who want to dig deeper into the world of data mining it should hold a wealth of good information!

Find it here: http://www.passbaconference.com/

Be there and be square (cube - really :)

//Joakim

SQL Server 2008 R2 Error: 'Using 'dbghelp.dll' version '4.0.5'

Just a quick note on this, in case there are people out there scratcing their heads over the errormessage "Using 'dbghelp.dll' version '4.0.5'" showing up over and over again in the SQL Server Errorlog for no apparent reason.

It can show up for many reasons of course, since it is written to the errorlog when sqldumper.exe is used. In many cases, this is then an indication of something bad going on in your system.

But, then again, if you see it all the time for no good reason, it is msot likely related to an Extended Event script, specifically one referencing the dmv sys.fn_xe_file_target_read_file wich is used to read the results from Extended Events. And in that case, there is nothing to worry about, you can safely ignore the message

Nya förbättringar för SQL Server 2008 R2 SP2

Stadigt utvecklas SQL Server och många är det som använder just SQL Server 2008 R2. För oss som gör det är det därför viktigt att kontrollera de förbättringar och buggar som man löst från Microsofts utvecklingsteam och sedan avgöra om man skall installera dessa förbättringar.

Helt nyligen har man släppt nya uppdateringar för SQL Server 2008 R2 och SP2 som man hittar nedan.

Cumulative update package 4 for SQL Server 2008 R2 SP2

Som vanligt gäller det att alltid testa innan man gör förändringar i sin produktionsmiljö.

Ny uppdatering för SQL Server 2012

Just innan årsskiftet kom ytterligare en förbättring för SQL Server 2012 RTM. Denna gäller alltså inte för SQL Server 2012 SP1.

SQL Server 2012 RTM Cumulative Update 5

Som vanligt gäller det att alltid testa innan man gör förändringar i sin produktionsmiljö.

Ny uppdatering för SQL Server 2008 R2 SP1

Många är de uppdateringar som kommit just innan årsskiftet. Så gjordes även för SQL Server R2 SP1. Nu finns det ju även SP2 för SQL Server 2008 R2, som man förstås bör använda. Väljer man ändå att ligga kvar med SP1 så bör man kontrollera dessa förbättringar som nu fått sin lösning och sedan avgöra om man skall installera denna uppdatering.

SQL Server 2008 R2 SP1 Cumulative Update 10

Som vanligt gäller det att alltid testa innan man gör förändringar i sin produktionsmiljö.

Hash table, parallelism and Cursor performance in practice

This Christmas my kids finally showed some interest in Lego and I got the opportunity to practice Hash tables, parallelism and cursors in reality. I saved all my Lego from my childhood to be able to pass them on to my kids. It’s more than 20 000 pieces (records) stored in one single box (like a table in SQL server) with the measure 70x40x40cm. The pieces are unsorted like a hash table without a clustered index, well, without any index at all.

The building instructions are very sequential, like a cursor, you have to get piece X from the box and connect to your construction before you continue to next step. In this case, my kid wanted to build a Bionicle fortress and to build it we need to get approximately 500 pieces and complete more than 50 steps.

Every piece (record) we need to get from the box (table) has some attributes (columns) that have to match, like color, size and shape, so we have to scan the pieces in the box to find the matching piece.

As you already figured out, the pieces are unsorted and can be anywhere in the box. For every piece we need to get, we have to scan all the pieces until we find the right one. In the worst case, we need to iterate through all 20 000 pieces >500 times. We can illustrate this with this pseudo code:

DECLARE curr CURSOR LOCAL FAST_FORWARD FOR
SELECT size, color, shape FROM [building instruction]

OPEN curr

DECLARE @size VARCHAR(10)
DECLARE @color VARCHAR(20)
DECLARE @shape VARCHAR(50)

FETCH NEXT FROM curr INTO @size, @color, @shape

WHILE @@FETCH_STATUS = 0
BEGIN
SELECT TOP 1 Piece FROM legoBox
WHERE size=@size AND color=@color AND shape=@shape

FETCH NEXT FROM curr INTO @size, @color, @shape
END
CLOSE curr
DEALLOCATE curr

The fun part with lego is not the search part, it’s the building part and to keep my joy for my kid we divided the work between us. He is the client requesting pieces, and I had to act as SQL engine.

When the client requested a piece, I had only one choice as the data is unsorted:

- Scan the box and stop when I found the piece, and keep doing this until all requests are handled

As you can see, this can be time consuming, due to the number of requests.

Well, I actually had a second choice. I could pick up pieces in chunks (data pages), sort them, keep them in my workspace (cache) and scan the workspace (cache) on subsequent requests. The sort phase of this approach is time consuming, but could save some time on subsequent requests.

The problem with the second approach is that the sort is time consuming and my workspace (cache) is limited and when I run out of workspace, I have to put the pieces (records) back into the box (table).

Do I have another option? Well, I could try to use some kind of qualified guessing and pick up pieces that I might need (read ahead). This can save some time, but consumes workspace with pieces that I might need.

I did try to use more kids (worker threads) to run the scan of the box in parallel to reduce the time, but the amount of work wasn’t evenly spread between the kids and me so one worker completed the scan faster than the others and had to wait for the rest of the worker (cxpacket waits) until the piece was found. The problem still exists, I have to scan the complete box for every piece that we needed.

The best option would have been to pick up all the pieces, sort them and stored them sorted in another box. That could save time depending on how I sort them. If I would give all pieces a unique number (a fictive key) and sort them by the number I wouldn’t save much time as I need to get them depending on the attributes:

- Size

- Color

- Shape

If I sort them based on the attributes I save a lot of time as I can to a quick seek (index seek) for every individual piece that the client requests, but I still get 500 requests.

The best option would be sorting them based on the Lego number, then I could get all the pieces I need for the building instruction into the workspace. As all 500 pieces fits in the workspace, I only need to scan the workspace, not seek as the pieces are not sorted by attributes.

Actually, the absolute best option would be sorting the pieces based on attributes and store all pieces for a construction in separate boxes (partitions). In this case I only need to seek for my piece in a subset of pieces (partition elimination). This will only take a fraction of the original time.

The problem with the last two options are that I haven’t stored the Lego number along with my pieces.

Conclusion:

- It is time consuming to scan unsorted data over and over again

- It is time consuming to sort the data, avoid doing it when you get your data

- Parallelism is good when the amount of work is evenly spread

- Iterations like cursors are time consuming

- Fetching sorted data can be really fast, depending on how the data is sorted

- Partitioning can increase the performance a lot, depending on the partitioning key

- Design your data model wisely from the beginning.

Recommendation for SQL server:

- Always create at least a clustered index for tables that contains more than just a few records

- Choose the clustered index wisely, a fictive key (like an identity column) doesn’t help you in your search as you never search for the fictive number

- Don’t waste your clustered index on columns you never use in filtering

- The clustered index need to be as narrow as possible as it is included in any other non clustered index.

- Create additional non clustered indexes to cover other search criteria

Some people recommends using a narrow and ever incrementing column as the clustered index, like an identity column, but that might cause you some trouble with:

- Key lookups, due to the fact that you never search the fictive key

- Hot spots in the last data page, as all data should be placed in the last page

- Statistics that are out of date as 20% of the table has to be changed before the statistics are auto updated.

On the other hand, if you don’t use an incrementing column you end up with page splits and fragmentation of the index.

To be able to tune your database for best performance you need to know your data and how it’s going to be used.

SQL Server statistics - memory request

In my previous blog post, I covered some issues with incorrect statistics and in this post I’ll present another issue. The optimizer is using the statistics to choose an execution plan that is as good as possible, but it also uses the row counts in the statistics to request memory for the query.

If the row count is higher than the actual number of records, the optimizer tells the SQL engine to request more memory than necessary, with possible memory exhaustion as a result.

But the worst case is when the row count is to low, because then the SQL engine will not request enough memory to process the query. SQL engine will not request more memory and the data will be spilled to tempdb.

If you are running a slow query, you can investigate the memory request for that query by using the following code:

SELECT
            [der].[session_id],
            [der].[request_id],
            [der].[start_time],
            [der].[status],
            [dest].[text],
            [deqp].[query_plan],
            [der].[user_id],
            [der].[wait_type],
            [der].[wait_time],
            [der].[last_wait_type],
            [der].[wait_resource],
            [der].[percent_complete],
            [der].[estimated_completion_time],
            [der].[cpu_time],
            [der].[total_elapsed_time],
            [der].[reads],
            [der].[writes],
            [der].[logical_reads],
            [der].[row_count],
            [der].[granted_query_memory],
            [deqmg].[session_id],
            [deqmg].[dop],
            [deqmg].[request_time],
            [deqmg].[grant_time],
            [deqmg].[requested_memory_kb],
            [deqmg].[granted_memory_kb],
            [deqmg].[required_memory_kb],
            [deqmg].[used_memory_kb],
            [deqmg].[max_used_memory_kb],
            [deqmg].[query_cost],
            [deqmg].[timeout_sec],
            [deqmg].[wait_order],
            [deqmg].[is_next_candidate],
            [deqmg].[wait_time_ms],
            [deqmg].[ideal_memory_kb]
FROM sys.[dm_exec_requests] AS der
CROSS APPLY sys.[dm_exec_sql_text](der.[sql_handle]) AS dest
CROSS APPLY sys.[dm_exec_query_plan]([der].[plan_handle]) AS deqp
LEFT JOIN sys.[dm_exec_query_memory_grants] AS deqmg ON
der.[session_id] = [deqmg].[session_id]
AND [der].[request_id] = [deqmg].[request_id]

If the max_used_memory_kb is much less the requested_memory_kb, then the optimizer over estimates the row count and requests more memory than needed.

The requested_memory can be forced to use more than whats necessary by changing the “min memory by query (kb)” by using this command:

EXEC sp_configure 'min memory per query (KB)',2048
RECONFIGURE

The default is 1024, but it might be worth changing if you know for sure that most of your queries requires a lot more and you have plenty of RAM.

If you have performance issues, feel free to contact any of our SQL server experts and we will help you.

Check progress of rollback

In SQL server, you can klii an active process using the command KILL <SPID> causing it to roll back any in flight transactions. And if you have killed a process, you can check the progress of the rollback by running KILL <SPID> WITH STATUSONLY. But sometimes, for various reasons (example), SQL Server does not return any status information even if sp_who2 and Activity Monitor shows that the SPID status is KILLED/ROLLBACK.

What I find tends to work every time however, it the following little query that you can run instead:

select session_id, percent_complete , last_wait_type , wait_resource, wait_time, wait_type from sys.dm_exec_requests where status = 'rollback'

In addition to the rollback percent complete, it gives you some info about if and what the process is waiting for, in case you feel it is taking a long time, and you want to investigate that.

As usual, feel free to contact us if you have SQL server questions, needs or problems!

Proposed improvement in T-SQL JOIN syntax

I have a proposal to enhance the T-SQL JOIN syntax, to simplify writing joins that use an existing PK/FK relationship.

The examples in this post uses the Adventureworks2012 database, and the [HumanResources].[Employee] and [Person].[Person] (Some parts edited out of CREATE scripts for readability)

OBS: This is regged as a CONNECT item, and if you think this is a good idea, you can vote for it here:

https://connect.microsoft.com/SQLServer/feedback/details/773543/proposed-improvement-in-t-sql-join-syntax

-- Start Setup script

SET ANSI_NULLS ON GO

SET QUOTED_IDENTIFIER ON GO

CREATE TABLE [HumanResources].[Employee]

( [BusinessEntityID] [int] NOT NULL,

[NationalIDNumber] [nvarchar](15) NOT NULL,

[LoginID] [nvarchar](256) NOT NULL,

[OrganizationNode] [hierarchyid] NULL,

[OrganizationLevel] AS ([OrganizationNode].[GetLevel]()),

[JobTitle] [nvarchar](50) NOT NULL,

[BirthDate] [date] NOT NULL,

[MaritalStatus] [nchar](1) NOT NULL,

[Gender] [nchar](1) NOT NULL,

[HireDate] [date] NOT NULL,

[SalariedFlag] [dbo].[Flag] NOT NULL,

[VacationHours] [smallint] NOT NULL,

[SickLeaveHours] [smallint] NOT NULL,

[CurrentFlag] [dbo].[Flag] NOT NULL,

[rowguid] [uniqueidentifier] NOT NULL,

[ModifiedDate] [datetime] NOT NULL,

CONSTRAINT [PK_Employee_BusinessEntityID]

PRIMARY KEY CLUSTERED ( [BusinessEntityID] ASC )WITH (STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF) )

ALTER TABLE [HumanResources].[Employee]

WITH CHECK ADD CONSTRAINT [FK_Employee_Person_BusinessEntityID] FOREIGN KEY([BusinessEntityID])

REFERENCES [Person].[Person] ([BusinessEntityID])

ALTER TABLE [HumanResources].[Employee] CHECK CONSTRAINT [FK_Employee_Person_BusinessEntityID]

CREATE TABLE [Person].[Person]

( [BusinessEntityID] [int] NOT NULL,

[PersonType] [nchar](2) NOT NULL,

[NameStyle] [dbo].[NameStyle] NOT NULL,

[Title] [nvarchar](8) NULL,

[FirstName] [dbo].[Name] NOT NULL,

[MiddleName] [dbo].[Name] NULL,

[LastName] [dbo].[Name] NOT NULL,

[Suffix] [nvarchar](10) NULL,

[EmailPromotion] [int] NOT NULL,

[AdditionalContactInfo] [xml](CONTENT [Person].[AdditionalContactInfoSchemaCollection]) NULL,

[Demographics] [xml](CONTENT [Person].[IndividualSurveySchemaCollection]) NULL,

[rowguid] [uniqueidentifier] ROWGUIDCOL NOT NULL,

[ModifiedDate] [datetime] NOT NULL,

CONSTRAINT [PK_Person_BusinessEntityID]

PRIMARY KEY CLUSTERED ( [BusinessEntityID] ASC )

WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY] ) ON [PRIMARY]

-- End Setup Script

Now, normally you would write a join like this:

USE AdventureWorks2012;

SELECT * FROM HumanResources.Employee AS e

INNER JOIN Person.Person AS p

ON e.BusinessEntityID = p.BusinessEntityID

What I propose is a simple improvement in syntax, that makes use of the informationa already contained in the datamodel, namely the foreign key relationship between the two tables. The syntax cold then look like the following:

-- Full syntax

USE AdventureWorks2012;

SELECT * FROM HumanResources.Employee AS e

INNER JOIN Person.Person AS p

ON REFERENCE

-- Short Syntax

USE AdventureWorks2012;

SELECT * FROM HumanResources.Employee AS e

INNER JOIN Person.Person AS p

ON REF

The idea would be that this would save time writing queries, and be more safe in case of a FK/PK column rename, or Foreign Key redefinition, as the query would still be valid, and not need to be updated, if the datamodel changes in this way. SQL Server should look up the actual definition of the FK relationship at compiletime, to obtain exact information of wich columns to use for the join. This would only work for joins of EQUAL (=) type, not for NOT EQUAL (<>), LARGER THAN (>), SMALLER THAN (<)and so on.

Multiple nulls in a unique constraint

Today I tried to earn some points at http://www.sqlservercentral.com/Questions by answer the "question of the day" and I learned something new, or at least I haven't thougt about it before. In SQL Server 2008 and later you can actually create a unique constraint that can contain multiple NULL values. This can be useful if you need to have unique values as long as the value is know.

It can be solved by filtered index, try the sample below.

USE [TEST] GO
CREATE TABLE [dbo].[tbl_test]( [id] [int] ) ON [PRIMARY]
GO
CREATE UNIQUE NONCLUSTERED INDEX UNCI_test ON [dbo].[tbl_test](id)
WHERE id IS NOT NULL
GO
--=======================================
insert into [dbo].[tbl_test] values(1)--success
insert into [dbo].[tbl_test] values(2)--success
insert into [dbo].[tbl_test] values(NULL)--success
insert into [dbo].[tbl_test] values(NULL)--success
insert into [dbo].[tbl_test] values(2)--error [Cannot insert duplicate key row in object 'dbo.tbl_test' with unique index 'NCI_test'.]
GO
select * from [dbo].[tbl_test]

SQL Server statistics - read only database

The default setting for auto create statistics is on in SQL server, and this setting enables the SQL engine to create column statistics as needed by the optimizer, BUT statistics are not created if the database is read only. Of course, that makes sense, but you might get terrible performance if you don't have the statistics.

If you intend to set the database to read only, make sure you create the statistics you need before you set the datase in read only, otherwise, the sql optimizer may choose a bad plan based on "guestimates".

SQL server statistics - table variables

Statistics are very important for the SQL query optimizer and is used for estimating number of records returned by a query. If the difference between estimated number of records and actual number of records are too big, the optimizer may choose a bad plan, with heavy performance loss as a result.

A common problem with statistics are caused by table variables, because SQL server doesn't have statistics for table variables. As SQL server is using a cost based optimization and statistics are a crucial factor for the cost estimation, there has to be an estimated number of records.

How is that solved? Well, SQL server is using 1 as estimated number of records, even if there are millions of records! Run the following query with "include actual qeuery plan" on and take a look at the estimaded vs actual number of records by hovering the mouse over the scan operator. You can also take a look at the io statistics in the message window. There is a big difference between the logical reads.

DECLARE @orderDetails TABLE(
SalesOrderID INT,
[SalesOrderDetailID] int,
[OrderQty] SMALLINT,
CarrierTrackingNumber NVARCHAR(25)
)

INSERT INTO @orderDetails( SalesOrderID, [SalesOrderDetailID], [OrderQty], [CarrierTrackingNumber] )
SELECT sod.[SalesOrderID], sod.[SalesOrderDetailID], [sod].[OrderQty], sod.[CarrierTrackingNumber]
FROM [Sales].[SalesOrderDetail] AS sod
WHERE sod.[OrderQty]>1

SELECT [od].[SalesOrderID], [od].[SalesOrderDetailID], [od].[OrderQty], [od].[CarrierTrackingNumber]
FROM @orderDetails AS od WHERE [OrderQty]>1

SET STATISTICS IO ON;
SET STATISTICS TIME ON;

SELECT * FROM [Sales].[SalesOrderHeader] AS soh
INNER JOin @orderDetails od ON [soh].[SalesOrderID]=[od].[SalesOrderID]
WHERE od [OrderQty]>1

SELECT * FROM [Sales].[SalesOrderHeader] AS soh
INNER JOIN [Sales].[SalesOrderDetail] AS od ON [soh].[SalesOrderID]=[od].[SalesOrderID]
WHERE od.[OrderQty]>1

SET STATISTICS IO OFF;
SET STATISTICS TIME OFF;

The solution:

Avoid using table variables for temp tables if they are likely to contain more than a few rows. As a rule of thumb, use temporary tables, rather than table variables, for temp tables with more than 100 rows.

Rätt datatyp ?

Om man ser en databas som innehåller "felaktiga" datatyper, så kan man ställa sig denna fråga "Har detta någon påverkan ?". Vad som menas med "felaktiga" datatyper kan man förstås diskutera, men normalt sett pratar vi om att datatyperna är onödigt "vida" och tar upp onödig plats. Normalt sett har man inte alltid möjlighet att testa detta, men här kommer nu ett fall som visar vilken påverkan detta gör. Många av tabellerna som ligger till grund för denna jämförelse innehåller kolumner av datatypen float som om inte annat defineras innebär 15 decimaler och en storlek av 8 bytes. Eftersom jag vet att här förekommer inga decimaler ändrar jag datatyperna till integer för samtliga kolumner som har float, vilket istället innebär 4 bytes per kolumn.

Detta gör denna skillnad i en fråga mot några av dessa tabeller :

Den första delen är alltså där datatyperna ännu innehåller float, medan det andra visar samma datamängd, samma data men med datatypen integer. Detta ger en förbättring på 7 gånger, bättre CPU-tid och som ni ser också andra skillnader när det gäller kostnaderna. Det är alltså enormt viktigt att verkligen välja rätt datatyp och inte slentrianmässigt välja varchar(50) till alla kolumner, som är ännu värre än detta exempel.

SQL Server statistics - multicolumn statistics

As you already know, in SQL server performance is depending on correct statistics. The optimizer in SQL engine uses the statistics to create execution plans, and if the statistics are incorrect or out of date, the optimizer is misguided, with inefficient execution plans.

The statistics are auto created by default when you are using a filter on a column or when you create an index, BUT did you know that multicolumn statistics are not created automatically? Well, for multi column indexes, the statistics are created.

Well, how does that affect you and your performance? For some cases it will not affect you at all, like when the tables are small and your T-SQL statements are simple, but if you have large tables and lots of joins etc, you might wonder why everything is so slow.

After some investigations you find an execution plans that is running slow and by looking at some of the access methods of the plan you find a big difference in estimated vs actual number of rows.

After running sp_updatestats, the estimates are still wrong, why? Well the optimizer looks at two different single column statistics and makes an incorrect estimate.

Try this sample:

-- create a table --

CREATE TABLE [dbo].[StatsTest](
[ID] [int] IDENTITY(1,1) NOT NULL,
[User][varchar](50)NULL,
[Company][varchar](50)NULL,
CONSTRAINT [PK_dbo.StatsTest]PRIMARY KEY CLUSTERED
(
[ID] ASC
)WITH (PAD_INDEX =OFF,STATISTICS_NORECOMPUTE =OFF,IGNORE_DUP_KEY=OFF,ALLOW_ROW_LOCKS =ON,ALLOW_PAGE_LOCKS =ON)ON[PRIMARY]
)ON[PRIMARY]
GO

-- insert some values --
INSERT INTO [dbo].[StatsTest]([user],[company])
VALUES('Håkan Winther','SQL Service')
GO 10000 --add 10000 records

-- insert some values --
INSERT INTO [dbo].[StatsTest]([user],[company])
VALUES('Håkan Winther1','SQL Service')
GO 10000

-- insert some values --
INSERT INTO [dbo].[StatsTest]([user],[company])
VALUES('Håkan Winther','SQL Service1')
GO 10000

DBCC DROPCLEANBUFFERS
DBCC FREEPROCCACHE

-- select some data --
SELECT * FROM[dbo].[StatsTest]
WHERE [USER]='Håkan Winther1'
AND Company='SQL Service';

-- check the stats to see if we got a multi column stats --
SELECT OBJECT_NAME([S].[object_id]),s.name,c.name,[S].[auto_created]
FROM sys.[stats] AS S
INNER JOI Nsys.[stats_columns]AS SC
ON [S].[object_id]=[SC].[object_id]
AND [S].[stats_id]=[SC].[stats_id]
INNER JOIN sys.columns c
ON sc.[object_id]=c.[object_id]
AND sc.[column_id]=c.[column_id]
WHERE s.[object_id]=OBJECT_ID('dbo.StatsTest');

-- create statistics manually --
CREATE STATISTICSmyStatsONdbo.StatsTest([user],Company);
GO

DBCC DROPCLEANBUFFERS
DBCC FREEPROCCACHE
GO

-- select from the table again --
SELECT * FROM [dbo].[StatsTest]
WHERE [USER] ='Håkan Winther'
AND Company='SQL Service1';

-- check the stats to see if we got a multi column stats --
SELECT OBJECT_NAME([S].[object_id]),s.name,c.name,[S].[auto_created]
FROM sys.[stats] AS S
INNER JOIN sys.[stats_columns] AS SC
ON [S].[object_id]=[SC].[object_id]
AND [S].[stats_id]=[SC].[stats_id]
INNER JOIN sys.columns c
ON sc.[object_id]=c.[object_id]
AND sc.[column_id]=c.[column_id]
WHERE s.[object_id]=OBJECT_ID('dbo.StatsTest');

DBCC SHOW_STATISTICS('dbo.StatsTest','myStats')

DROP TABLE dbo.StatsTest;

As you can see, the estimates are more correct when you have a multicolumn statistics

Solution:

You have two options to solve this problem, the best option is to create a multicolumn index.
Another options is to create multicolumn statistics

If you want to know more, feel fre to contact any of our SQL serrver experts and we will help up.

SQL Server performance - death by power options

If your SQL server isn't constantly busy you might experience unpredictible performance. Why? Well, you might have missed the small detail in Windows, the power options. The default setting for power option in Windows is "balanced power", and that setting is forcing the hardware, like CPU and storage to throttle down to save power when the system is less busy!

To make things even worse, if you are using Windows Server 2008R2, you have some new power saving options, “core parking” (temporarily suspending certain cores) and “tick skipping” (extended idle and sleep states).

If you care more about performance and less about the environment, you should change the power option to "High performance".

Why is the default setting, balanced power? I may only guess, but a default action when installing a SQL server should be changing the option, not only in Windows but also in BIOS if the BIOS have support for power saving.

You can read more about the power option death at:

http://www.brentozar.com/archive/2010/10/sql-server-on-powersaving-cpus-not-so-fast/

http://www.sqlskills.com/blogs/paul/post/are-your-cpus-running-slowly-tool-tip-and-survey.aspx

http://www.bradmcgehee.com/2010/07/windows-os-power-saving-feature-directly-affects-cpu-performance/

or if you are living in the virtual world, read this:

http://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1018206

Nya utbildningsmöjligheter

I morgon torsdag 6/12 mellan kl 17-23 finns möjlighet att lära sig mer om Performance när det gäller SQL Server. Under dessa tider går nämligen sex stycken sessioner i detta viktiga ämne i ett mini "24 Hours of PASS".

Vilka sessionerna är och mer information hittar ni här:

http://performance.sqlpass.org/2012Palooza.aspx

SQL Server Central Question of the day challenge

At http://www.sqlservercentral.com/Questions you can test your knowledge and improve you skills by trying to answer the "question a day". It takes no more than 5 minutes a day to answer a question and you earn points if you answer correct. Some questions are really tricky and not too obvious.

This is a fun and powerful way of learning something new. Personally I have earned 2024 points and are at position 143. This week I challenged all my collegues to answer at least 1 question a day during 2013 and the collegue that earn most points during the next year will earn a price. The points will be counted from 2013-01-01 to 2013-12-31 to make sure everyone has the same oppertunity.

In this challenge, everyone is a winner.

Take the chance and challenge your collegues during 2013 and have fun while you learn.

/Håkan Winther

SQL Server - death by mountpoints

This is another blog post in the Death by series, but has nothing to do with performance. Well, the case that led to this blog post had to do with performance in the first place, as the drive where tempdb resided was super slow with average disk read time aboce 350ms. In this blog post I’ll cover the death of a SQL server instance by moving the tempdb to a new location, like in this case at the root of a mount point.

Last week a client of mine had to move the tempdb to a larger volume, and he sent me a script for verification and everything seemed fine.

USE master;
GO

ALTER DATABASE tempdb
MODIFY FILE (NAME='tempdev', FILENAME='i:\Temp_mountpoint\tempdb.mdf');
GO

ALTER DATABASE tempdb
MODIFY FILE (NAME='templog', FILENAME=' i:\Temp_mountpoint\tempdb.ldf');
GO

A couple of minutes later he ran the script and restarted the SQL server instance running on a 4 node cluster. After a couple of minutes I tried to connect to the instance to make sure everything worked as expected. To my surprise the instance was still not running, and after another couple of minutes I knew something was terribly wrong.

The SQL server instance was failing during the startup and in the eventlog there were a couple of error messages, like:

CREATE FILE encountered operating system error 5(failed to retrieve text for this error. Reason: 15100) while attempting to open or create the physical file 'I:\tempdb_mountpoint\tempdb.mdf'.

Could not create tempdb. You may not have enough disk space available. Free additional disk space by deleting other files on the tempdb drive and then restart SQL Server. Check for additional errors in the event log that may indicate why the tempdb files could not be initialized.

Well there were plenty of space available in the new volume and the SQL service account was granted full access to the directory. The first error message is complaining about “access is denied” and the second about “not enough disk space”, what’s going on here?

I started the instance with minimal configuration by using:

Sqlserver.exe -s name_of_instance -f

Then I logged on as administrator in the instance, created a new file for tempdb data and one for the log. The files appeared in file explorer, so the SQL server account could create new files appearantly!

I created a sub directory beneath the root of the mount point, moved the files to the sub directory and restarted the instance without minimal configuration and everything worked just fine.

This behavior felt strange and I couldn’t came up with a logical explanation so after some searching the Internet, I found this connect item:

http://connect.microsoft.com/SQLServer/feedback/details/569895/installation-of-sql-server-2008-r2-on-mount-points-fails

It turned out to be a bug in the Windows API when using mount points!

If you want to know more about SQL server, feel free to contact any of our SQL server experts.

/Håkan Winther

SSAS Compare

Här kommer ett tips på bra verktyg från Red Gate, nämligen helt nya SSAS Compare. Som namnet antyder används det för att hitta skillnader mellan två SSAS miljöer. Detta är version 1.0 och just nu är den helt gratis. Vi återkommer senare när vi har utvärderat det mera, men vid första testerna ser det ok ut. Som ni ser av bilderna nedan så liknar det "SQL Compare" som används flitigt av oss som jobbar med SQL Server databaser. "SSAS Compare" skall alltså användas på samma sätt för att skripta ut skillnader.

http://www.red-gate.com/labs/free-tools/ssas-compare

Nya förbätringar för SQL Server 2012 SP1

Det kändes som alldeles nyss vi fick SP1 för SQL Server 2012. Den lanserades ju under PASS Summit den 7 november och Ted Kummerts dragning. Nu är det i alla fall ytterligare förbättring tillgängliga för SQL Server 2012 då nästan 50 stycken förbättringar/fixar blivit åtgärdade för SP 1. Som vanligt bör man alltid först studera vilka förbättringarna är, avgöra om man skall installera dem och i så fall förstås göra det först i sin testmiljö innan man går till produktion.

En av dessa förbättringar är denna och vem vill inte ha denna rätt i sin miljö ? :

FIX: Incorrect results when you run a parallel query that uses a columnstore index in SQL Server 2012.

When you run a parallel query in Microsoft SQL Server 2012, you may receive incorrect results. This problem occurs if the following conditions are true:

•The query runs against a partitioned table that has a columnstore index.
•The query uses an aggregate function over the columnstore index.

Cumulative update package 1 for SQL Server 2012 Service Pack 1

Ny uppdatering för SQL Server 2008 SP3

Helt nyligt har man från Microsoft släppt förbättringar för SQL Server 2008 och SP3. Som alltid bör man studera vilka förbättringarna är och sedan avgöra om man skall installera dem. Dock bör man förstås göra det först i sin testmiljö innan man går till produktion.

Nu finns det det ju en orsak till att man släpper dessa uppdateringar, och se nedan en av förbättringarna eller rättare sagt buggfix'en.

FIX: Incorrect result is returned when you query an indexed view by using the NOEXPAND hint in SQL Server 2008

Consider the following scenario:

•You create an indexed view for two tables that have a foreign key reference in Microsoft SQL Server 2008.
•You update the base tables of the indexed view.
•You run a query against the indexed view that uses the NOEXPAND hint.

In this scenario, you receive an incorrect result.

Cumulative update package 8 for SQL Server 2008 Service Pack 3

SQL Server 2012 SP1

Som vanligt vill man alltid lansera något "till massorna" vid PASS Summit som nu går av stapeln i Seattle. Detta innebar i år service pack 1 för SQL Server 2012. Denna har varit ganska väntad länge då man släppt CTP i flera omgångar. Nu finns den i alla fall tillgänglig för nedläddning som man hittar här och den består av närmare 60 rättningar sedan RTM versionen.

SQL Server performance - Death by xp_cmdshell

In SQL server there is an extended procedure, called xp_cmdshell, which you can use to execute commands and programs outside the SQL server process. It can be useful if you need to do something that is not supported by the T-SQL language, like secure copy, BUT there are some major risks attached to the use of xp_cmdshell. Personally, I am not a frient of xp_cmdshell.

Besides the security risk there is another risk that may strike you like lightning. What happens if you are using xp_cmdshell within a procedure called from SQL agent and the program you execute throws an error that can’t be caught by xp_xmdshell.

Assume you are using xp_cmdshell to execute secure copy and the program can’t find the path specified. Xp_cmdshell will wait for a response from secure copy, but secure copy doesn’t send a response and xp_cmdshell will wait for a long, long, long time. That's what happened to a client recently.

When you finally realize that you have a process that is hung, the first thing you probably will try is to kill the process. But what will happen? If you kill a process with a transaction, SQL server will roll back the transaction, but how in the world are going to roll back a transaction with a failing external program!?

Now you have a process (spid) that is stuck in the middle of a restore, and the worst part is that any locks acquired on rows, pages or tables are not released.

Assume that no locks are acquired and you can live with the stuck process for a while, until you can restart the SQL service instance. What happens with the SQL Agent job that called the procedure in the first place? Well, you can’t restart the job, because SQL Agent job is still running.

How do you solve this issue? The most obvious, is to avoid the issue in the first place.

Årets upplevelse i repris ?

Ett tips om man missade någon session från årets nyss avslutade PASS Summit är att helt enkelt ladda ned dessa. Detta är nu möjligt här. För er som inte hade möjlighet att vara på plats i Seattle eller somnade från någon livesändning finns det ännu möjlighet att köpa dessa på ett USB. Mer uppgifter om detta hittar ni här.

SQL Rally Nordic 2012

För oss som missade SQL Rally Nordic i Köpenhamn tidigare i år finns det det möjligt att lyssna och se de sessioner som var under dessa dagar i mars. Detta kan man göra här och massor av godbitar finns, t.ex. Conor Cunningham med "SQL Server 2012 Query Optimizer deep dive".

Fullständig SQL Server Management Studio med SQL Server 2012 SP1

I samband med att Microsoft släppte Service Pack 1 för SQL Server 2012, kom en god nyhet för er som använder SQL Server Express. Från och med 2012 SP1 kommer den fulla versionen av SSMS att ligga med om man kör SQL Server Express With Tools, SQL Server Express COMP, SQL Server Express with Advanced Services eller SQL Server Management Studio Express.

Det finns även en hel del annat att glädjas över, i form av till exempel möjligheten att migrera en AlwaysOn Availability group från ett kluster till ett annat och selektiva XML index. Mer information om SQL Server 2012 SP1 hittar du här: http://msdn.microsoft.com/en-us/library/bb500435

PASS Summit 2013

Efter 5 år i Seattle kommer PASS Summit förflyttas till östkusten nästa år, nämligen Charlotte, NC vilket innebär lite kortare flygresa för oss svenskar och bara 6 timmars tidskillnad :-). Tydligen kommer man ha basen för PASS Summit i Seattle även i framtiden med tanke på närheten till Microsoft i Redmond och med jämna mellanrum förlägga det till andra platser för att få med sig ännu mer deltagare. I år samlades nästan 4000 personer från 57 länder och även om den största gruppen är amerikaner så vi var inte så få svenskar vilket är kul och att så pass många insett att detta Nr 1 när det gäller utbildning/konferens när det gäller SQL Server. Nästa års datum är 14-18 oktober och som vanligt tjänar man på att boka tidigt och detta kan man göra här.

Hekaton SQL Server mystery revealed!

As some of you might remember, I published this http://sqlservice.se/sv/start/blogg/sql-server-mystery-hekaton-tables-and-hekaton-procedures.aspx blogpost back in June, when I stumbled upon a mysterious reference inside SQL Server to something called Hekaton.

Well, it is no longer a mystery, as Microsoft has just announced (More details here: http://blogs.technet.com/b/dataplatforminsider/archive/2012/11/08/breakthrough-performance-with-in-memory-technologies.aspx) the In Memory technology Hekaton to be released in the next major version of SQL Server. There is not a lot of public information available yet apart from that blogpost, but from what I have seen and heard so far, it seems very exiting, and we could be standing on the edge of the next big leap in database technology.

The key points to take away from now is

- Hekaton is for high voulme OLTP solutions

- It is built in to the SQL Server product, and accessed using standard T-SQL, menaning it is (almost) transparent to your applications

- Hekaton tables are all in memory, but you can choose to persist the data

- Persistence is done in an optimized way (sequential data write) and indexes are never persisted

- Hekaton stored procedures are T-SQL procedures that are compiled into native code to run very much faster

- Scale Up is provided by taking away all locking and latching. ACID is provided trough versioning

- This is just the beginning, more cool improvements to Hekaton are already in the making !!

We can hope for a public CTP in the summer of 2013, and a RTM during 2014. But as usual, there are no guarantees that those dates will hold in the end.

PASS Summit 2012 - Dag 2

Som väntat nästan blev det en väldigt bra gårdag med Peter Myers och heldagssessionen om SSAS 2012. Har är ju en välkänd och uppskattad talare med bra planering av sin tid och många av hans olika sessioner går ju ladda ned t.ex. denna: http://channel9.msdn.com/posts/SQL11UPD06-REC-01.

Vi var ca 200 personer i lokalen och uppskattningsvis är det ca 1600 som kommer till dessa två dagar med förkonferenserna. Av dessa är det faktiskt rätt stor del svenskar vilket förstås är kul. Själva sessionen gick igenom de olika alternativ man nu har med SQL Server 2012 och Peter byggde samma lösning med gamla "Multidimensional Mode" fastän nytt namn, och nya "Tabular Mode". Av hela dagen tog bara "Tabular-lösningen" 1/3 del av dagen att utveckla och dema, jämfört med gamla sättet att bygga kuber tog minst dubbetlt så länge. Märkligt nog kom de flest frågor på gamla sättet som borde varit välkänt jämfört med det nya. Som vanligt beror det sedan på många faktorer vilket sätt man sedan väljer för att utveckla BI-lösningar. Dock är det ju rätt troligt att de flesta nya lösningar kommer bli med "Tabular Mode" eftersom det går så mycket fortare, är lättaresom vi såg och vårt gamla sätt faktiskt funnit rätt länge nu även om det har sina fördelar t.ex "Translation" vilket inte ännu finns bl a.

PASS Summit 2012

Så har det åter blivit dags för PASS Summit, och som de senaste åren i Settle. Största skälet till just Seattle är närheten till Microsoft i Redmond och det är ju inget dåligt skäl. Som i fjol inleds veckan med två heldagssessioner innan det "riktiga" programmet drar igång på allvar. Själv hade jag inte möjlighet till dag 1, men nu är det dag 2 som gäller och för mig med Peter Myers och "Zero to BI Semantic Model with SQL Server 2012", som handlar om de val och möjligheter man har att utveckla BI-lösningar med SQL Server 2012. Troligtvis kommer denna dag handla mycket om "Tabular Model" som är den stora nyheten i SQL Server 2012 Analysis Services, men mer om detta senare.

Den enda nackdelen med just Seattle är avståndet hit för oss nordbor, men ett bra sätt att fördriva tiden och förbereda sig för denna dag har varit att läsa "SQL Server 2012 Analysis Services The BISM Tabular Model" ISBN-13: 978-0-7356-5818-9, som jag varmt kan rekommendera. Boken går grundligt igenom hela processen med bakgrund, installation, utveckling och underhål av just "Tabular Model"l. En av författarna är Marco Russo som man förresten kan höra och träffa i Stockholm redan den 29 november, men som tyvärr redan är fullsatt.

En av nyheterna för året när det gäller PASS att man kan följa vissa sessioner live. Detta kan man göra från onsdag och mer om detta hittar ni här.

Seattle är ju ett känt regnställe, men än har jag inte sett regn utan bara härligt höstväder :-)

Ladda ner vår Windows 8 app

SQL Service har låtit utveckla en Windows 8 app för att enklare kunna titta på våra blogginlägg på dator, telefon och Microsoft Surface som har Windows 8 som operativsystem.

Klicka på följande länk för att komma till Windows Store:

http://apps.microsoft.com/webpdp/sv-SE/app/sql-service/9e739aea-b6f1-46ab-83da-0f5814acf29e

Identifiera problem med parametersniffning

Denna vecka har jag tittat lite på prestandaproblem i SQL Server orsakade av parametersniffning. Jag tänkte skriva en längre blogpost om det, men så hittade jag denna http://blogs.msdn.com/b/sqlcat/archive/2010/06/09/identifying-query-compile-runtime-parameter-values-using-xml-showplan-output.aspx som redan handlade om i stort sätt det jag ville säga. Så då får det istället bli en refenrens till det blogginlägget!

Utöver det du kan läsa dig till där, kan jag tipsa om några situationer där man kan bli extra hårt drabbad:

- Om du har ojämn datadistribution i dina tabeller

- Om du har dåliga/saknade index

- Om din statistik är utdaterad

- Om du bygger om index, och därefter jobbar mot en liten del av datat i tabellerna som har ojämn distribution.

Vad kan du då göra? Jo, du kan till exempel testa några av följande saker:

- Ta bort den specifika dåliga Query Planen

- Använd Trace Flag 4136 (OBS: TESTA DETTA FÖRST!!!)

- Använd flaggan OPTIMIZE FOR UNKNOWN, alternativt OPTIMIZE for parameter x = value y

- Bygg om index igen på den aktuella tabellen

- Uppdatera statistiken igen på den aktuella tabellen

- Skapa en Plan Guide med "rätt" plan

Eller, så kan du givetvis höra av dig till oss så kan vi hjälpa till!

Copy with Headers - SQL Server 2005

En nyhet som kom med SQL Server 2008 var möjligheten att kopiera med kolumnrubrikerna tillsammans med resultatet från en grid.

För SQL Server 2005 finns inte detta menyalternativ.

Dock är det ju faktiskt möjligt redan med SQL Server 2005, även om det krävs att man konfigurerar SSMS för detta enligt bilden nedan.

Lärdomar från installation

Nyligen installerade jag ett nytt SQL2005 kluster.
Att kunder fortfarande kör på gamla versioner är inte ovanligt men att en kund vill ha ett nyinstallerat SQL2005 kluster hör inte direkt till vanligheterna. Dock så gjordes installationen på Windows Server 2008.

Sagt och gjort, installationen startades och slutfördes utan problem. Gick sedan in i kluster managern och förväntade mig att hitta SQL Server som resurs i klustret men icke! Någonstans ringde en klocka i bakhuvudet om att man måste installera minst SP2 för SQL Server 2005 innan den blir synlig i kluster managern. Mycket riktigt, efter installation av SP3 dök den upp.

Referens: http://support.microsoft.com/kb/932897

Nästa sak som inträffade var när jag skulle konfigurera tempdb. Baserat på kundens behov kom jag fram till att tempdb skulle vara 48GB fördelat på 8 filer. Filer lades till och utökades.

Tempdb skulle dessutom enligt alla konstens regler ligga på egen disk vilket innebar att den behövde förflyttas från sin ursprungliga plats. Alla som gjort detta vet att man måste starta om SQL Server innan flytten blir fullständig. SQL Server startades om men kom inte upp igen....vad var nu detta?

Eftersom jag utökat tempdb till 48GB så tog det helt enkelt lite tid att skapa filerna (rätt lång tid). Lärdom att dra av detta är att först flytta tempdb och sedan efter det utöka filerna.

Slutet gott, allting fungerar nu utan problem.

Några Trace Flags för SQL Server

Om du vill ändra på Microsoft SQL Servers standardbeteende, finns det många inställningar du kan göra till exempel med hjälp av sp_configure, eller via Properties på SQL Server instansen i Management Studio. Men vissa saker kan man enbart nå via så kallade Trace Flags, som man ställer in som startup option i SQL Server Configuration Manager (för permanent förändring) eller med hjälp av DBCC TRACEON (För tillfällig förändring)

Syntaxen i SQL Server Configuration Manager är ";-T<trace flag number>". Exempel: ";-T 1117"

Det finns en hel mängd Trace Flags, men jag tänkte bara helt kort nämna några av dom för att ge en känsla av vad du kan göra på detta sätt. Om du klickar på länkarna nedan finns det mer information, även om Trace Flags som inte nämns i denna artikel. Dock vill jag påpeka att Trace Flags är mycket avancerade alternativ, och du bör läsa in effekterna noga och testa i din egen testmiljö innan du ändra i din produktionsmiljö. Eller hör av dig till oss, så hjälper vi dig.

Så, här kommer några Trace Flags att fundera på!

834: Large Page Allocations, ger prestandaförbättringar om man har mycket minne och eller mycket CPU

Referens: http://support.microsoft.com/kb/920093

1118: Force Uniform Extent Allocation. Tar bort vissa flaskhalsar som kan uppstå vi allokering av många objekt samtidigt i Tempdb:

Referens: http://blogs.msdn.com/b/psssql/archive/2008/12/17/sql-server-2005-and-2008-trace-flag-1118-t1118-usage.aspx

4136: Parameter Sniffing behaviour alteration. Tar bort en del av problemen med ”parameter sniffning” som man kan få till exempel i Dynamics AX, när man har väldigt olika mycket data i de olika bolagen.

Referens: http://blogs.msdn.com/b/axinthefield/archive/2010/11/04/sql-server-trace-flags-for-dynamics-ax.aspx

1117: Simultaneous Autogrowth in Multiple-file databases. Ser till att en databas med flera datafiler utökar alla filerna (i samma filegroup) när mer utrymme behövs. Detta medför att proportional fill algoritmen fungerar även efter auto growth.

Referens: http://blogs.technet.com/technet_blog_images/b/sql_server_sizing_ha_and_performance_hints/archive/2012/02/09/sql-server-2008-trace-flag-t-1117.aspx

Årets sista uppdatering av SQL Server 2008 R2 ?

Rätt nyligt har åter en uppdatering av SQL Server 2008 R2 släppts. Denna gäller för de som redan hunnit installera SP2 och uppdateringen heter nu CU 3. Som vanligt bör man kontrollera de förändringar som skett och därefter avgöra om man skall uppdatera sin SQL Server miljö. Det är ju tyvärr ganska vanligt att man inte uppdaterar sin miljö efter att man gjort den initiala installation med den sk RTM versionen. Detta bör man förstås göra och RTM versionen är förresten sedan i sommar osupporterad av Microsoft.

Förbättringar som skett av SQL Server 2008 R2 hittar man här:

http://support.microsoft.com/kb/2754552

Kerberos - part 2

Recap from last week:

Well, you can easily verify that Kerberos validation is active by executing the following query:

select auth_scheme from sys.dm_exec_connections where session_id=@@spid

Answer: "KERBEROS" <= YES, you´re all set! "NTLM" <= NO, it´s still not working.

So, you get the annoying "NTLM" reply from the query, now what?

The most common problem is that you have multiple registrations in Active Directory!

Run this in a CMD prompt: setspn -X

This command will list all duplicate registrations in the AD and if you find the following lines:

------------------------------------------------------------

Checking domain DC=nydomain,DC=local

...

MSSQLSvc/nystromsql.nydomain.local:1433 is registered for these accounts:

CN=nystromsql,OU=servers,OU=up,DC=nydomain,DC=local

CN=sqlservices,OU=SYSTEM,OU=ACCOUNTS,OU=up,DC=nydomain,DC=local

...

You have two accounts registered for the MSSQLSvc service.

The solution to this is simply to remove the duplicate account. The only account that should be listed is the one that you entered in the SETSPN in last weeks session. If Kerberos finds a duplicate, it will always fall back to NTLM!

Problem solved!

//Joakim

SQL Server management studio Shortcuts part 1

In SQL server management studio there are a lot of shortcuts and one of the new shortcuts in SQL server 2008 is the shortcut for selecting text by columns in the query editor window. Lets say you want to change the alias for a table you need to change all the columns that is using the table alias. All you do is place the cursor where you want to start the selection and hold the SHIFT + ALT keys while you use the arrow keys to expand the selection like the image below.

If you want to use the mouse, you hold the ALT key and drag the mouse to expand the selection.

If you are using SQL server 2012 you can actually replace the selection by entering a new text and all rows will get the new text.

Edition Upgrade från Evaluation Edition

Om du installerade SQL Server 2012 Evaluation Edition när SQL Server 2012 släpptes i våras, kommer du nu snart (om inte redan) att upptäcka att du inte längre kan använda den. Utvärderingsperioden på 180 dagar har gått ut.

När du bestämmer dig för att köpa en licens, behöver du då ominstallera hela SQL Server instansen? Nej, som tur är behöver du inte det! Du kan göra en så kallad Edition Upgrade, som innebär att du lyfter SQL Server Edition från Evaluation till till exempel Enterprise, Standard eller Developer. det är mycket enkelt att göra, och tar bara några minuter.

- Ta fram media för den Edition du vill uppgradera till, och starta installationen.

- Välj "Maintenance"

- Välj "Edition Upgrade"

- The first part of the normal setup starts, klick your way forward to the Product Key page

- Enter the Product key (unless it is already filled in)

- Accept the terms

- Choose your SQL Server 2012 Instance(s)

- Klick your way forward, klick "Upgrade"

- Done! Should not take more than 5 minutes in total.

Uppdatering för SQL Server 2012

Alldeles nyligen har man från Microsoft släppt ytterligare en uppdatering av SQL Server 2012. Som vanligt bör man kontrollera de förändringar som skett och därefter avgöra om man skall uppdatara sin SQL Server miljö. Tyvärr är det alltför vanligt att man inte uppdaterar sin miljö efter att man gjort den initiala installation. Detta bör man förstås göra och här kommer de förbättringar som skett av SQL Server 2012.

24 Hours of PASS 2012

För er som som missade att få ett smakprov av kommande SQL Pass Summit 2012, nämligen 24 Hours of PASS så går det nu att ladda ner sessionerna . Många av sessionerna var mycket bra och nu finns det möjlighet att ladda ner samtliga av dessa. Som sagt många bra sessioner och dessa är max 60 minuter långa. Nytt för i år är det också är möjigt att ladda ned presentationerna. Allting hittar man här.

Kerberos - getting it to work.

Sometimes you want to do double-hop querying in SQL Server, for example if you add a linked server connection ot your server and you want to query objects on that server from your client. Now, if you run integrated security (native mode) and you want your credentials to validate you from the client over the server and to the linked server, you will have to enable Kerberos.

I think that many have had problems with this (as I frequently see special accounts set up in the linked server definition). Here I put together a short recipe for those of you to try at home (or at work).

Step 1: Active Directory settings (http://support.microsoft.com/kb/917409):

All accounts (users and computers) must belong to the same directory/forest.
The user account must NOT be specified as a sensitive account (not for delegation).
The user account must be specified as "trusted for delegation".
Also, all involved computers must be "trusted for delegation".

Step 2: Run cmd command "setspn" (assuming you are running the listener on the standard port 1433) (The following may look like the same lines repeated, but trust me, you need all of them!!)

SETSPN -A MSSQLSvc/<NetBIOS servername> <sql service account>
SETSPN -A MSSQLSvc/<NetBIOS servername>:1433 <sql service account>
SETSPN -A MSSQLSvc/<FQDN servername> <sql service account>
SETSPN -A MSSQLSvc/<FQDN servername>:1433 <sql service account>

In my home network NYDOMAIN where my sql server is named NYSTROMSQL.nydomain.local and the sql service account is NYDOMAIN\sqlservice the commands would thus be as follows: (run in CMD shell)

SETSPN -A MSSQLSvc/NYSTROMSQL NYDOMAIN\sqlservice
SETSPN -A MSSQLSvc/NYSTROMSQL:1433 NYDOMAIN\sqlservice
SETSPN -A MSSQLSvc/NYSTROMSQL.nydomain.local NYDOMAIN\sqlservice
SETSPN -A MSSQLSvc/NYSTROMSQL.nydomain.local:1433 NYDOMAIN\sqlservice

So now you´re done! Everything is working...or is it?

Well, you can easily verify that Kerberos validation is active by executing the following query:

select auth_scheme from sys.dm_exec_connections where session_id=@@spid

Answer:

"KERBEROS" <= YES, you´re all set!
"NTLM" <= NO, it´s still not working.

I will return next week with what to do if you receive "NTLM", good luck!

//Joakim Nyström

Alternativ till PASS Summit

PASS Summit 2012 i Settle närmar sig med stormsteg. Precis som i fjol hålls två dagar med heldagssessioner innan hela programmet drar igång på allvar. Detta kräver att man registrerar sig och förstås betalar för dessa två heldagar. Har man nu inte hunnit det kan man istället titta på detta alternativ SQL In The City som är helt gratis och går på måndag den 5/11.

Agenda och amälan hittar man här.

Hitta de största tabellerna

Ibland vill man veta vilka tabeller som tar upp utrymmet i en vissa databas, till exempel om du upplever ökad tillväxt eller helt enkelt vill ta reda på om det finns stora tabeller som du borde städa ut historiskt data ur. Det är ju så att 1 GB data i din databas lätt kan kräva 10 GB lagringsutrymme totalt, om man räknar  in backup utrymme, redundans på disknivå, test och utvecklingsmiljöer och så vidare.

Ett enkelt sätt att titta på detta är att högerklicka på databasen och välja Reports -> Standard Reports -> Disk Usage By Top Tables Du får då en rapport som ser ut såhär:

Om du vill göra detta lite mer automatiserat, och inte högerklicka för mycket, kan du givetvis skriva ihop ett script för detta. Eller så kan du köra Profiler, och fånga frågan som rapporten ovan kör, och anpassa den lite. Då kan du få ut en kodsnutt som ser ut ungefär som den nedan, som du sedan kan anpassa för eget behov:

SELECT TOP 10    (row_number() over(order by (a1.reserved + ISNULL(a4.reserved,0)) desc))%2 as l1,

 a3.name AS [schemaname],    a2.name AS [tablename],    a1.rows as row_count,

(a1.reserved + ISNULL(a4.reserved,0))* 8 AS reserved,    a1.data * 8 AS data,

 (CASE WHEN (a1.used + ISNULL(a4.used,0)) > a1.data

THEN (a1.used + ISNULL(a4.used,0)) - a1.data ELSE 0 END) * 8 AS index_size,

(CASE WHEN (a1.reserved + ISNULL(a4.reserved,0)) > a1.used

THEN (a1.reserved + ISNULL(a4.reserved,0)) - a1.used

ELSE 0 END) * 8 AS unused

FROM

(SELECT    ps.object_id,    SUM (    CASE    WHEN (ps.index_id < 2) THEN row_count    ELSE 0    END    ) AS [rows],

 SUM (ps.reserved_page_count) AS reserved,

SUM (    CASE    WHEN (ps.index_id < 2)

THEN (ps.in_row_data_page_count + ps.lob_used_page_count + ps.row_overflow_used_page_count)

ELSE (ps.lob_used_page_count + ps.row_overflow_used_page_count)

END    ) AS data,

SUM (ps.used_page_count) AS used

FROM sys.dm_db_partition_stats ps

GROUP BY ps.object_id) AS a1

LEFT OUTER JOIN

 (SELECT    it.parent_id,    SUM(ps.reserved_page_count) AS reserved,    SUM(ps.used_page_count) AS used

 FROM sys.dm_db_partition_stats ps

INNER JOIN sys.internal_tables it ON (it.object_id = ps.object_id)

WHERE it.internal_type IN (202,204)

GROUP BY it.parent_id) AS a4 ON (a4.parent_id = a1.object_id)

INNER JOIN sys.all_objects a2  ON ( a1.object_id = a2.object_id )

INNER JOIN sys.schemas a3 ON (a2.schema_id = a3.schema_id)

WHERE a2.type <> N'S' and a2.type <> N'IT'

Till exempel kan informationen sparas till en tabell för att kunna gå bakåt och titta på historisk information, för att kunna se trender.

Vad är PDW ?

Att PDW står för Microsoft SQL Server Parallel Data Warehouse kanske många vet redan. Vad det däremot innebär kanske inte är helt känt för så många. Här kommer därför en länk där man kan lära sig mer om detta och också SQL Server Data Warehousing och Big Data. Allting är förpackat i en serie om 4 korta videosnuttar som ni hittar här.

Some insights to the transactionlog

When managing your Microsoft SQL Server and its databases the transaction log is really important. If you fail set the log to appropriate size, and potential autogrowth to adecvate size you will jeopardize the integrity and function of the database. You need to have a view of how the log is constructed. On monday, if you're close by the Microsoft HQ in Kista I'm talking about the log, and some about the do's and don't's about the log.

Alot of the demos will use DBCC LOGINFO(), an undocumented good dbcc feature that exposes great intel to the logfile. the transaction log file is just a wrapper for Virtual Log Files, VLFs. They are created based on a calculation of the size the log grows. When the growth chunk is up to 64MB there are four (4) VLFs, up to 1GB there are eight (8) VLFs, and larger than 1GB there are sixteen (16) VLFs. You want to have them tuned based on your database need.

Another important thing that is worth mentioning is that the growth of the log cannot utilize the Instant File Initialization as the new chunk of the log must be zeroed out.

There is also a bug around log growth, if the chunk of growth are a multiple of 4GB (4096MB/4196304kB/4294967296B, the first autogrowth will fail and just create a small chunk, the second will work. 4000MB is a better choice than 4096MB or 4GB. This goes for 8GB, 12GB, 16GB and so on as well.

You must also remember that when the log grows all changes to the database is locked out as the file is being zeroed out. Test out the most optimal size based on your environment.

So, if you want some insight on your environment this script will get all user-databases and dump the info about the transaction logs into a table variable.

USE master

DECLARE @loginfo TABLE

 db sysname NULL, -- The name of the database

 RecoverUnitId numeric(34,0), -- The Recover Unit ID

 FileID numeric(34,0), -- The File ID of the transaction log

 FileSize numeric(34,0), -- The size of the VLF

 StartOffset numeric(34,0), -- Where in the log file is the VLF starting

 FSeqNo numeric(34,0), -- Sequencial ID for the VLFs

 Status numeric(34,0), -- 0 = not in use, 2 = contains transactions

 Parity numeric(34,0), -- 0 = not in use, 64/128 = contains transactions/current transactions

 CreateLSN numeric(34,0) -- The Log Sequence Number when the VLF was created

DECLARE

 @db sysname,

 @stmt nvarchar(max) = N'DBCC LOGINFO(''{db}'')',

 @exec nvarchar(max)

DECLARE loop CURSOR

FOR

 SELECT name FROM sys.databases

 WHERE name NOT IN ('master','msdb','tempdb','model')

OPEN loop

FETCH NEXT FROM loop INTO @db

WHILE @@FETCH_STATUS = 0

 BEGIN

 SET @exec = REPLACE(@stmt, N'{db}', @db)

 INSERT INTO @loginfo

 RecoverUnitId,

 FileID,

 FileSize,

 StartOffset,

 FSeqNo,

 Status,

 Parity,

 CreateLSN

 EXEC(@exec)

 UPDATE @loginfo

 SET db = @db

 WHERE db IS NULL

 FETCH NEXT FROM loop INTO @db

END

CLOSE loop

DEALLOCATE loop

SELECT * FROM @loginfo ORDER BY db ASC, StartOffset ASC

How to get Cisco VPN to work on Windows 8

As a SQL server DBA consultant you once in while need to connect remote to your clients server and you can't choose the VPN software and have to use your clients solution. If you already have upgraded to Windows 8 and need to use Cisco VPN 5.0.7 you realize that the VPN client is not compatible with Windows 8.

Don't give up, there is a simple solution to this fix.

Open the regedit.exe
Browse the registry key HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Services\\CVirtA
Export the original registry key
Change the value DisplayName to:
- for x86 system: "Cisco Systems VPN Adapter”
- for x64 system: "Cisco Systems VPN Adapter for 64-bit Windows”
Close regedit
Try connect with VPN client

If this doesn't work replace the setting to the original value with your exported registry key.

Veckans fråga - vecka 39

Veckans fråga går till Håkan Winther som har stor erfarenhet av felsökning och optimering i stora och komplexa miljöer.

Finns det något verktyg för SQL Server där man i efterhand kan kontrollera vilka queries som låstes på grund av andra queries, kanske med hjälp av en profilerdump eller ... ?.

Vad är Data Profile Viewer ?

Data Profile Viewer måste vara en av de mest dolda tillämpningarna som finns för SQL Server. Någon kanske tänker att det måste var en nyhet för SQL Server 2012. Så är det dock inte utan detta kom redan med SQL Server 2008.

Skälen till använda Data Profile Viewer är bl a dessa :

- Analysera källdatat mer effektivt
- Förstå källdatat bättre
- Förhinda datakvalitetsproblem före de hamnar i ett datavaruhus

Nedan följer en kort demonstration av hur man använder detta förträffliga program.

Första steget man måste göra är att skapa ett SSIS paket. Därefter använder man objektet Data Profiling Task.

Det första man gör att att skapa en destination för filen som kommer skapas, en xml fil alltså.

Nästa steg är att välja källan som skall analyseras enligt nästa bild, mha knappen Quick Profile. Jag väljer databasen AdventureWorks och alla tabeller. Detta går förstås bra att bara analysera enstaka tabeller också. Dessutom går det här att välja vilka analyser man vill göra, men jag väljer standardvalen.

Därefter är det bara starta SSIS paketet som vanligt och vänta till allt är klart.

Nu är vi redo att presentera datat och en förbättring som faktiskt kommit med SQL Server 2012 är att man kan öppna objektet och sedan mha Open Profile Viewer göra just detta, ... Det går också bra att göra som nedan

Efter att öppnat den skapade filen finns nu massor av intressant information. Nedan ser vi t.ex. max och min-längder för kolumnen Name och att UnitMeasureCode har 3 olika längder med procentuell fördelning mellan dessa.

Bilden nedan visar de unika värden som finns och t.ex. för kolumnen NameStyle så finns det bara ett värde och dessa är 19972 till antalet och vilka de är ser man sedan på den allra sista raden.

Det var bara några av de möjligheter som finns med detta program och en klar fördel för oss som t.ex. skall migrera data eller utveckla datavaruhus. En klar fördel är ju också hur enkelt det är att ta fram denna information samt att det också ingår i SQL Server sviten utan extra kostnad.

Varför TPC-E ?

Om du är intresserad av SQL Server prestanda, eller databas prestanda generellt, har du säkert någon gång tittat in på Transaction Processing Council's hemsida på http://www.tpc.org/

Det som är anmärkningsvärt är att om du tittar på sidan med alla TPC-E resultat som någonsin publicerats http://www.tpc.org/tpce/results/tpce_results.asp så ser du att det finns många olika Server HW leverantörer representerade, men bara en databashanterare, nämligen Microsoft SQL Server.

Det jag ville tipsa om denna gång, är detta blogginlägg från Microsoft, som förklarar hur de ser på TPC-E och varför de är de enda som lämnat in godkända och validerade reultat.

Trevlig läsning!

SSDT in Visual Studio 2012 missing SSIS, SSAS and SSRS tools

Looking for SSIS and SSAS (and maybe even SSRS) tools on the new platform Visual Studio 2012?

I have, and cound not find them anywhere.

You are going to have to wait a bit longer, because these plug-ins have not yet been converted to the latest version of the platform. Keep an eye (e.g. RSS) on the following site for updates, they should not be long waiting for:

http://blogs.msdn.com/b/ssdt/

Meanwhile you can run the 2010 version of the tools in parallell with the 2012 installation.

Good Luck!

//Joakim

SQL Server 2012 SP1 CTP4 ute!

För Er alla beta-/CTP-/EAP-/... därute som gillar att testa nya verktyg, finns nu service pack 1 av SQL Server 2012 att tillgå:

Alla nödvändiga länkar finns här:

Uttdrag från MSDN artikeln:

The following highlights a few key enhancements in CTP4:

•A solution to migrate AlwaysOn Availability Group from a lower version of Windows Server cluster to a higher version of Windows Server cluster.

•Selective XML Index which will improve querying performance over data stored as XML

•For SQL Server 2012 Express users, SQL Server 2012 SP1 Express Edition will ship the SQL Server Management Studio with functionality that existed with the SQL Server Management Studio from SQL Server premium editions

Veckans fråga med svar vecka 38

Veckans fråga går till Jan Nieminen som har stor erfarenhet av olika driftsmiljöer.

Vi ser nu att Red Gate lanserat ny version av sin programvara för backup ”SQL Backup Pro 7.2”. Vad är dina erfarenheter av denna eller liknande och är det verkligen värt merkostnaden jämfört med att använda SQL Servers egna backup/restore funktioner ?

http://www.red-gate.com/products/dba/sql-backup/?utm_source=simpletalk&utm_medium=email-main&utm_content=dbateam_7_2-20120917&utm_campaign=sqlbackup

Svar:

Som alltid när man skall investera i tilläggsprodukter likt Red-Gate Backup PRO eller Quest LiteSpeed skall man vara tydlig med nyttan av produkten. SQL Server har redan väldigt mycket av funktionaliteten som dessa produkter erbjuder inbyggt, kanske inte alltid lika flott presenterat men ändock så finns det där och man har redan betalat för det.

Backupkomprimering i samband med backuptagning var tidigare ett försäljningsargument som man som kund lätt kunde räkna hem och gjorde produkterna prisvärda men i och med att det finns inbyggt i SQL Server Standard Edition och uppåt from 2008R2 får man istället fokusera på andra fördelar och funktioner. Detta har även mjukvarutillverkarna upptäckt eftersom de bygger in mer och mer funktionalitet i produkterna som kanske inte direkt har att göra med just bara backup/restore.

Nu menar jag inte att produkter som tex Red-Gate Backup PRO inte är prisvärda, det beror helt och hållet på vad man skall använda dem till. Om man tittar lite närmare på ovan nämnda produkt så hittar man en mängd bra och nyttiga funktioner som hjälper en DBA att göra rätt, tex så finns en funktion för att testa sina backuper. Man kan helt enkelt sätta upp jobb som flyttar en backup till annan server, gör restore, kör DBCC CHECKDB för att verifiera att backupen inte är korrupt. Att ta backup gör de flesta men att sedan testa sina backuper är mer sällsynt, alla kanske inte ens är medvetna om att det är en bra idé att regelbundet testa sina backuper, men genom att funktionen finns där blir man som DBA påmind om att backuper behöver kontrolleras. Därtill kan produkten även fungera som ett bra stöd för en mer oerfaren DBA.

En nackdel, förutom att det kostar pengar, är att man får en produkt till att installera, underhålla och uppgradera med allt vad det innebär. Om man har en stor miljö med hundratals servrar kan en uppgradering ta mycket tid i anspråk vilket jag själv bevittnat på nära håll. En annan nackdel är att man blir beroende av ytterligare ett lager i mjukvarustacken. Personligen vill jag vid en krissituation ha så kort väg till restore som möjligt och vara beroende av så få komponenter som möjligt, enkelhet är värt pengar den dag det är skarpt läge.

Nu kanske det verkar som att jag är stark motståndare till produkter som dessa, det är jag inte. Nyckeln ligger i vad produkten har för merväde utöver det som redan finns i SQL Server och hur man värderar detta? Innan man slår till gör man klokt i att noggrant utvärdera nyttan och försöka att sätta en prislapp på det samt fundera på om man verkligen kommer att använda alla funktioner och vad det då innebär för nyttan. Om man sedan även kommer fram till att vardagen kraftigt förenklas av att använda sig av Backup PRO eller LiteSpeed är det naturligtvis en viktig faktor, en nöjd och glad DBA går inte att sätta en prislapp på :-)

På SQL Service jobbar vi med att hjälpa kunder att utnyttja SQL Server till fullo, vi hjälper gärna till med att utvärdera alla möjligheter som finns inbyggt och som man redan betalat licenspengar för.

/Janne

24 Hours Of PASS

På torsdag 20/9 är det dags för höstens "24 Hours Of PASS", 24 stycken sessioner under ett helt dygn. Detta innebär att vi får vi ett smakprov på några av sessionerna under kommande PASSSummit i Seattle i 5-9 november. Förstås handlar det denna gång mycket om SQL Server 2012 och Azure, men även felsökning, exekveringsplaner och t.ex. "Choosing the Right Reporting Platform" som är den första sessionen man kan följa under dessa 24 timmar.

Regstreringen gör man här:

http://www.sqlpass.org/24hours/fall2012/SessionsbySchedule.aspx

Vad är RunAs Radio ?

Detta är en ganska okänd informationskanal som faktiskt innehåller rätt många bra godbitar om t.ex. SQL Server.

Här är några av dem:

Hela innehållet innehållet hittar ni här.

Keeping track of Replication statistical data using Extended Events

The other day I had reason to think about how to get more reliable statistics about the number of commands beeing replicated between SQL Servers. As you might know, Replication Monitor can give you information like that, but it is not very reliable, and also does not easily expose information that you can track, say in you favourite management or monitoring tool. So I came up with the idea to try to use Extended Events to collect that info, due to it's lightweight nature. Below here, you will find a script to set it up.

The idea is based on the fact that the replication subscription is run via an SQL Server Agent job, that is uniquely named based on Publisher server name, database name and subscription database name. And it is one job per article. Also, SQL Server replication uses stored procedures to insert, update or delete information in the destination (subscription ) database, and if you update 1000 rows with one UPDATE command on you publication database, it will result in 1000 individual calls to the sp_MSIns_<tablename> stored procedure at the subscriber database.

The script creates a table to store data, an Extended Events session to collect data, a stored procedure to move the data from the EE session to the table, and a stored procedure to return an integer that is the number of commands (rpc completed events) executetd by the SQL Server Agent job specified as a parameter to the get_repl_stats procedure.

The idea is that you would run this script on your destination (subscription) server once, then run the get_repl_stats proc every 5 minutes from you monitoring software, specifying the name of the job that you are interested in. Sounds confusing? Don't worry, I actually put some comments into the code ;-)

Enjoy!

-- Replication speed monitoring -- By: SQL Service, Steinar Andersen -- Created: 2012-09-18

-- Part 1: Create objects for data collection, in master database

-- Create Results table, wich will hold the data collected via Extended Events

USE [master]

IF EXISTS ( SELECT * FROM dbo.sysobjects WHERE id = OBJECT_ID(N'[DF_repl_stats_history_last_updated]') AND type = 'D' )

BEGIN

ALTER TABLE [dbo].[repl_stats_history] DROP CONSTRAINT [DF_repl_stats_history_last_updated]

END

USE [master]

IF EXISTS ( SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[repl_stats_history]') AND type IN ( N'U' ) )

DROP TABLE [dbo].[repl_stats_history]

USE [master]

CREATE TABLE [dbo].[repl_stats_history]

( [JobName] [varchar](150) NULL ,

[EventCount] [int] NULL ,

[EventsTrunc] [int] NULL ,

[last_updated] [datetime] NULL

)

ON [PRIMARY]

ALTER TABLE [dbo].[repl_stats_history]

ADD CONSTRAINT [DF_repl_stats_history_last_updated] DEFAULT (GETDATE()) FOR [last_updated]

USE [master]

IF EXISTS ( SELECT * FROM sys.indexes

WHERE object_id = OBJECT_ID(N'[dbo].[repl_stats_history]')

AND name = N'Idx_Last_Updated' )

DROP INDEX [Idx_Last_Updated] ON [dbo].[repl_stats_history] WITH ( ONLINE = OFF ) GO

USE [master]

CREATE CLUSTERED INDEX [Idx_Last_Updated] ON [dbo].[repl_stats_history]

( [last_updated] ASC, [JobName] ASC )

WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, SORT_IN_TEMPDB = OFF, IGNORE_DUP_KEY = OFF,

DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON, FILLFACTOR = 90) ON [PRIMARY]

-- Create an Event Session to Track RPC Completed per Client App Name

IF EXISTS ( SELECT * FROM sys.server_event_sessions WHERE name = 'Repl_Stats' )

DROP EVENT SESSION [Repl_Stats] ON SERVER;

CREATE EVENT SESSION [Repl_Stats] ON SERVER

ADD EVENT sqlserver. rpc_completed -- Count RPC Completed, as Replication uses Stored Procedures to make changes at the Subscriber. One SP will be fired per row changed, so the count of SP's run will equal number of rows impacted

( ACTION ( sqlserver. client_app_name )

--WHERE (sqlserver.client_app_name = 'Microsoft SQL Server Management Studio - Query')

--The Client Application name or names that you want to monitor. Replication will use one SQL Serve Agent Job for each replication article subscription. The Client App Name here is obviously just an example. )

ADD TARGET package0. asynchronous_bucketizer --Target=Bucket, as we only want to store the number of times the event is fired

( SET source_type=1, source='sqlserver.client_app_name' --Group events fired by Client App Name )

WITH ( MAX_DISPATCH_LATENCY = 5 SECONDS )

-- Create proc to save stats and recycle counter.

IF EXISTS ( SELECT * FROM sys.objects

WHERE object_id = OBJECT_ID(N'[dbo].[save_repl_stats]')

AND type IN ( N'P' ) )

DROP PROC [dbo].[save_repl_stats]

CREATE PROC dbo.save_repl_stats

BEGIN

SET ANSI_PADDING ON

INSERT INTO master.dbo.repl_stats_history

( JobName ,

EventCount ,

EventsTrunc ) --Insert data into history table

SELECT ( n.value('(value)[1]', 'varchar(max)') ) AS JobName ,

n.value('(@count)[1]', 'int') AS EventCount ,

n.value('(@trunc)[1]', 'int') AS EventsTrunc

FROM

( SELECT CAST(target_data AS XML) target_data

FROM sys.dm_xe_sessions AS s

JOIN sys.dm_xe_session_targets t ON s.address = t.event_session_address

WHERE s.name = 'Repl_Stats'

AND t.target_name = 'asynchronous_bucketizer' )

AS tab

CROSS APPLY target_data.nodes('BucketizerTarget/Slot') AS q ( n )

ALTER EVENT SESSION [Repl_Stats] -- Stop EE session to zero out the values

ON SERVER

STATE=STOP

ALTER EVENT SESSION [Repl_Stats] -- Start EE session to start collecting values again

ON SERVER

STATE=START

END

-- Schedule data collection proc as job to run every 5 minutes. -- This job will fail the first time only, because the EE session is not started. Pay no attention to that! ;-)

USE [msdb]

IF EXISTS ( SELECT job_id FROM msdb.dbo.sysjobs_view WHERE name = N'Collect Replication Statistics' ) EXEC msdb.dbo.sp_delete_job @job_id = N'9f703264-a99b-4285-9688-856a3031baf1', @delete_unused_schedule = 1 GO

USE [msdb]

BEGIN TRANSACTION DECLARE @ReturnCode INT SELECT @ReturnCode = 0

DECLARE @jobId BINARY(16) EXEC @ReturnCode = msdb.dbo.sp_add_job @job_name = N'Collect Replication Statistics', @enabled = 1, @notify_level_eventlog = 0, @notify_level_email = 0, @notify_level_netsend = 0, @notify_level_page = 0, @delete_level = 0, @description = N'Uses Extended events to collect SQL Server Replication Statistics every 5 minutes Usage: exec master.dbo.get_repl_stats ''<jobname>''', @category_name = N'[Uncategorized (Local)]', @owner_login_name = N'sa', @job_id = @jobId OUTPUT IF ( @@ERROR <> 0 OR @ReturnCode <> 0 ) GOTO QuitWithRollback

EXEC @ReturnCode = msdb.dbo.sp_add_jobstep @job_id = @jobId, @step_name = N'Save Replication Statistics', @step_id = 1, @cmdexec_success_code = 0, @on_success_action = 1, @on_success_step_id = 0, @on_fail_action = 2, @on_fail_step_id = 0, @retry_attempts = 0, @retry_interval = 0, @os_run_priority = 0, @subsystem = N'TSQL', @command = N'exec dbo.save_repl_stats', @database_name = N'master', @flags = 0 IF ( @@ERROR <> 0 OR @ReturnCode <> 0 ) GOTO QuitWithRollback EXEC @ReturnCode = msdb.dbo.sp_update_job @job_id = @jobId, @start_step_id = 1 IF ( @@ERROR <> 0 OR @ReturnCode <> 0 ) GOTO QuitWithRollback EXEC @ReturnCode = msdb.dbo.sp_add_jobschedule @job_id = @jobId, @name = N'Repl_Stats', @enabled = 1, @freq_type = 4, @freq_interval = 1, @freq_subday_type = 4, @freq_subday_interval = 5, @freq_relative_interval = 0, @freq_recurrence_factor = 0, @active_start_date = 20120917, @active_end_date = 99991231, @active_start_time = 0, @active_end_time = 235959, @schedule_uid = N'90561def-ba8e-4339-b5f4-8cbf605408b1' IF ( @@ERROR <> 0 OR @ReturnCode <> 0 ) GOTO QuitWithRollback EXEC @ReturnCode = msdb.dbo.sp_add_jobserver @job_id = @jobId, @server_name = N'(local)' IF ( @@ERROR <> 0 OR @ReturnCode <> 0 ) GOTO QuitWithRollback COMMIT TRANSACTION GOTO EndSave QuitWithRollback: IF ( @@TRANCOUNT > 0 ) ROLLBACK TRANSACTION EndSave:

-- Part 2: Create objects to retrive data USE [master]

-- Create proc to get repl stats data -- Usage: exec master.dbo.get_repl_stats '<jobname>'

IF EXISTS

( SELECT * FROM sys.objects

WHERE object_id = OBJECT_ID(N'[dbo].[get_repl_stats]')

AND type IN ( N'P' ) )

DROP PROC [dbo].[get_repl_stats]

CREATE PROC dbo.get_repl_stats @jobname VARCHAR(150)

BEGIN

SELECT TOP 1 ISNULL(eventcount, 0) AS ReturnValue

FROM master.[dbo].[repl_stats_history]

WHERE JobName = @jobname

AND last_updated > DATEADD(minute, -5, GETDATE())

ORDER BY last_updated DESC END

--The End!

(CREDIT: I stole some code/ideas from Jonathan Kehiyas blogpost while creating this!)

Gästblogg: Hur får du till de där nyheterna på MS BI plattan?

Du gick på ett förklätt säljmöte i form av en session från en slipad Powerpoint konsult för att få se nyheterna i BI-plattformen. Sharepoint+PowerPivot+PowerView+Excel Services+PerformancePoint+SQL 2012 tabular model och SQL 2012 engine. Allt är sproilans, gärna beta och riktigt fancy-schmanzy och du ser möjligheter. Lösningen som ska befria dina användare och få sanden att bli guld.

Så du har fått 2 dagar av kunden för att installera Sharepoint 2010 SP1, på en 2 server-farm med Web på ena och SQL 2012 på den andra. OK. Det är lite trickigt. Kan gå. Även om du inte sett Sharepoint tidigare, så får du ta hjälp av en konsultfirma att kapa lite av tiden genom att hålla i handen. De har stor erfarenhet av sharepoint. Men inte BI och inte på SQL 2012. Och du läser på prerequisites först och beställer konton och servrar, AD-rättigheter och sånt i god tid innan så kanske ändå?

Skulle du köra under de förutsättningarna? Tja, hur ska du annars få jobba med de där roliga nya verktygen. Så du kör!

De här enades konsulten och jag om:

1. Hårdvara och mjukvara
2. Installationsmedia med Product Key
3. Lista på Services som ska installeras
4. Domänkonton för SharePoint och SQL (vi valde att ha 12 st systemkonton)
5. Personer och resurser
6. Internetanslutning för konsultens PC
7. Installationsguide

Och letar rätt på ett par stycken installationsguider på nätet (officiella och blog-varianter) och mergar ihop till en ungefärlig plan som passar dina parametrar av topologi,arkitektur, servermiljö, förkunskaper, slutanvändarbehov, driftbarhet, förändringsbarhet osv.

Sen ska du dessutom lägga på Business Intelligence komponenterna. Ok. Nu vet du att du behöver äska mer timmar. Men kommer inte få några. Så du kör.

Nu har SQL 2012 funnits ute ett tag. Föregången av långa alfa, beta perioder med Denali och saker som hyfsat fungerar ihop. Men inget servicepack har kommit ännu. Och Microsofts dokumentation får betraktas som beta tills tillräckligt många kört skarpt ett tag. Bered dig på en ordentligt skumpig resa.

Hos oss började det med alias för sql burken. Vi ville ha sharepoint webbservern skyddad mot framtida migreringar av SQL instanser så vi letade information om Alias och hur man sätter det i SQL Configuration Manager på web-serverns sql klient. Googlande gav resultat. Däremot stod det inte på samma ställe om att eftersom Management Studio är en x86 applikation så kan du inte lägga upp alias under vanliga SQL Native Client 11.0 Configuration utan under SQL Native Client 11.0 Configuration (32bit). Där gick 1,5 timmar av felsökanden, googlande, ändra, testa, googla mer, ändra testa osv. Ära den som äras bör:

http://www.mssqltips.com/sqlservertip/1620/how-to-setup-and-use-a-sql-server-alias/

Vår driftsleverantör gav oss en färdig SQL setup på SQL servern – med ett lokalt konto som kör tjänsterna. Så där slapp vi undan. Men jag undrar om jag inte föredragit att köra den själv så man vet vad som är gjort… :-)

Dags att installera Sharepoint 2010 och SP1. Föredömligt nog fanns en kombinerad setup + sp1 att tanka ner från Microsoft Volume Licences. Den här installationsplanen hade vi i grova drag när vi började, några punkter är redigerade/borttagna för att ”skydda oskyldiga”. PowerPivot, RS och PowerView väntade vi dock med till senare när vi väl kom dit.

1. Starta Splash-filen i foldern där installationsfilerna ligger.
2. Välj Install software Prerequisites.
3. Välj Install SharePoint Server.
4. Ange Product Key.
5, Välj att installera Server Farm.
6. Välj Server Type Complete.
7. Välj var installationsfilerna ska ligga i File Location.
8. Checka i Run Configuration Wizard och klicka på Close.
9. När den startat klicka på Next och svara Yes.
10. Välj Create a new server farm.
11. Ange Database server: mindomän\minserveralias (Ett sql-alias bör användas här)
12. Ange Database Name: Min_SharePoint_Config_DB
13. Ange ett konto för Database Access: Mitt_konto
14. Skriv in en Passphrase och konfirmera den: använd ett komplext lösenord. Passphrase för att kunna lägga till servrar i sharepoint-farmen senare.
15. Fyll i Specify a port number: t ex 8080
16. Välj NTLM eller Negotiate (Kerberos). Kan ändras senare.
17. Klicka Next och den kör 10 steg.
18. Central Administration startar med Configure your SharePoint farm.
19. Innan wizarden startas så ska Managed Accounts skapas.
20. I SharePoint Central Administration, välj Security.
21. Välj Configure managed accounts.
22. Välj Register Managed Account och skapa ett managed account för varje service account. Så kan man välja konton I listboxar I sharepoint vid senare referenser, smutt!
23. Installera följande BI Services (gjorde vi alltså senare iofs):
23.1.PowerPivot 2012
23.2.Reporting Services – SSRS 2012
23.3.PowerView for SP 2010
24. Starta Farm Configuration Wizard och checka av de services som ska ha egna accounts:
24.1.Excel Services Application
24.2.PerformancePoint Service Application
24.3.User Profile Service Application
25. Ange SP_ServiceApps för de services som wizarden ska konfigurera.
26. Gå till Manage Service Applications och välj Create New och ange namn på App Pool och konto:
26.1.Excel Services Application – SP_Excel
26.2.PerformancePoint Service Application – SP_PerfPoint
26.3.PowerPivot 2012 – SP_PowerPivot
26.4.Reporting Services – SSRS 2012 – SP_PerfPoint
26.5.PowerView for SP 2010 – SP_PowerPivot
26.6.User Profile Service Application – SP_Farm
27. Skapa en Web Site Collection för verifiering
27.1.Välj Classic Mode Authentication och NTLM
28 Skapa en Site Collection för verifiering

Där började nästa överraskande ”task”– visar sig att Sharepoint har ytterligare prerequisites för mjukvara, som den själv försöker tanka ner från nätet. Sitter så klart på en server utan internet koppling J. Blir till att köra, få felmeddelande, sök media, ladda ner, packa upp, kör setup, ”RETRY” på sharepointen ett gäng varv för”Microsoft Chart Controls for .Net 3.5”, ”Microsoft Server Speech Platform Runtime (x64)”, ”Microsoft Sync Framework Runtime v1 (x64)”, ”Microsoft SQL Server Analysis Services ADOMD.NET” (feature pack, men du måste hitta rätt version också, den med ”content created” 4/2/2009 8:08 AM fungerade för oss), ”Microsoft SQL Server 2008 Native Client”, ”Windows Identity Foundation KB974405”, ” Microsoft SQL 2008 R2 Reporting Services SharePoint 2010 Add-in”, ”Microsoft Filter Pack 2.0”.

Efter ett tag hittade vi var man skulle plocka ihop dem, i ett powershell skript som Brian Lalancette @brianlala gjort, tack för den!:

$UrlList = ("http://download.microsoft.com/download/C/9/F/C9F6B386-824B-4F9E-BD5D-F95BB254EC61/Redist/amd64/Microsoft%20Sync%20Framework/Synchronization.msi", # http://go.microsoft.com/fwlink/?LinkID=141237&clcid=0x409 - Microsoft Sync Framework Runtime v1.0 (x64)

"http://download.microsoft.com/download/c/c/4/cc4dcac6-ea60-4868-a8e0-62a8510aa747/MSChart.exe", # "http://go.microsoft.com/fwlink/?LinkID=141512" - Microsoft Chart Controls for the Microsoft .NET Framework 3.5

"http://download.microsoft.com/download/2/0/e/20e90413-712f-438c-988e-fdaa79a8ac3d/dotnetfx35.exe", # http://go.microsoft.com/fwlink/?LinkId=131037 - Microsoft .NET Framework 3.5 Service Pack 1

"http://download.microsoft.com/download/2/8/6/28686477-3242-4E96-9009-30B16BED89AF/Windows6.0-KB968930-x64.msu", # "http://download.microsoft.com/download/2/8/6/28686477-3242-4E96-9009-30B16BED89AF/Windows6.0-KB968930-x64.msu" - Windows PowerShell 2.0

"http://download.microsoft.com/download/D/7/2/D72FD747-69B6-40B7-875B-C2B40A6B2BDD/Windows6.1-KB974405-x64.msu", # "http://go.microsoft.com/fwlink/?LinkID=166363" - Windows Identity Framework (Win2008 R2)

"http://download.microsoft.com/download/6/8/1/681F5144-4092-489B-87E4-63F05E95079C/Windows6.0-KB976394-x64.msu", # http://go.microsoft.com/fwlink/?linkID=160770 - WCF fix for Win2008 SP2

"http://download.microsoft.com/download/E/C/7/EC785FAB-DA49-4417-ACC3-A76D26440FC2/Windows6.1-KB976462-v2-x64.msu", # http://go.microsoft.com/fwlink/?LinkID=166231 - WCF fix for Win2008 R2

"http://download.microsoft.com/download/D/7/2/D72FD747-69B6-40B7-875B-C2B40A6B2BDD/Windows6.0-KB974405-x64.msu", # "http://go.microsoft.com/fwlink/?LinkID=160381" - Windows Identity Framework (Win2008 SP2)

"http://download.microsoft.com/download/3/5/5/35522a0d-9743-4b8c-a5b3-f10529178b8a/sqlncli.msi", # "http://go.microsoft.com/fwlink/?LinkId=123718&clcid=0x409" - SQL Server 2008 Native Client

"http://download.microsoft.com/download/9/1/3/9138773A-505D-43E2-AC08-9A77E1E0490B/1033/x64/SQLSERVER2008_ASADOMD10.msi", # "http://go.microsoft.com/fwlink/?LinkID=160390&clcid=0x409" - Microsoft SQL Server 2008 Analysis Services ADOMD.NET

"http://download.microsoft.com/download/1/7/1/171CCDD6-420D-4635-867E-6799E99AB93F/ADONETDataServices_v15_CTP2_RuntimeOnly.exe", # "http://go.microsoft.com/fwlink/?LinkId=158354" - ADO.NET Data Services v1.5 CTP2 (Win2008 SP2)

"http://download.microsoft.com/download/B/8/6/B8617908-B777-4A86-A629-FFD1094990BD/iis7psprov_x64.msi", # http://go.microsoft.com/?linkid=9655704 - IIS management cmdlets

"http://download.microsoft.com/download/1/0/F/10F1C44B-6607-41ED-9E82-DF7003BFBC40/1033/x64/rsSharePoint.msi", # http://go.microsoft.com/fwlink/?LinkID=166379 - SQL 2008 R2 Reporting Services SharePoint 2010 Add-in

"http://download.microsoft.com/download/8/D/F/8DFE3CE7-6424-4801-90C3-85879DE2B3DE/Platform/x64/SpeechPlatformRuntime.msi", # http://go.microsoft.com/fwlink/?LinkID=166378 - Microsoft Server Speech Platform Runtime

"http://download.microsoft.com/download/E/0/3/E033A120-73D0-4629-8AED-A1D728CB6E34/SR/MSSpeech_SR_en-US_TELE.msi" # http://go.microsoft.com/fwlink/?LinkID=166371 - Microsoft Server Speech Recognition Language - TELE(en-US)

SQL Servern vill också nå update services för att tanka ner senaste version. Ingen internet. Får vänta till efteråt. Kommer på efter ett tag att ”skip” är bra att använda där.

Varför stannar den så länge på registry kollarna. Hur svårt ska det va?

Bara PowerPivot delen med olika konto-varianter, googling etc, nya försök, reboot och så vidare tog sammanlagt 6 timmar att felsöka, la upp en connect på den till sist när vi till slut hittade en work-around. Rösta gärna om du vill ha en förbättring av den. https://connect.microsoft.com/SQLServer/feedback/details/763299/setup-powerpivot-on-an-existing-sharepoint-server-farm-account-provisioning

Där var de två dagarna slut. Letar tid och pengar för fortsättning. Eller så får man ta sin fritid.

Lessons learned (igen). Det går inte att vara helt förberedd på en sån här uppgift, även att läsa in sig på ämnet tar din (och företagets) dyrbara tid. ”Improvise, adapt and overcome” är det enda som funkar i längden, gärna med hjälp av andras försök och frikostiga självutlämnande beskrivningar i bloggar och forum.

Fortsättning följer. Kanske. :-)

Jonas Bergström

SQL server - kolumn alias best practice

Att använda alias i SQL har många fördelar och är helt nödvändiga i vissa situationer, som exepelvis vid användade av common table expression (CTE). Nedanstående exempel skulle generera ett felmeddelande:

;WITH myCTE
AS
(
SELECT GETDATE(), t.Name FROM sys.Tables t
)
SELECT * FROM myCTE;

-----------------------------------------
Msg 8155, Level 16, State 2, Line 1
No column name was specified for column 1 of 'myCTE'.

Enligt ANSI standarden för SQL så skall man använda:

uttryck AS alias

Det innebär att föregående fråga skall då alltså skrivas:

;WITH myCTE AS ( SELECT GETDATE() as currentDateTime, t.Name FROM sys.Tables t ) SELECT * FROM myCTE;

I det här exemplet så är det ganska enkelt att se vad GETDATE() uttrycket har för alias, men anta att du har en komplex uträkning blandat med en lång CASE sats etc, så att antingen raden eller uttrycket blir så lång att du inte kan snabbt se ditt alias. Då blir koden ganska snabbt svår att tolka. Ännu värre blir situationen om du har en INSERT sats där du ska lägga in rätt uttryck i rätt kolumn.

Eftersom antalet columner, datatyper, etc i tabellen där datat skall läggas till måste matchas med kolumnerna i SELECT listan så kan det lätt bli frustrerande när man får fel på grund av :

att fel antal kolumner är angivna i SELECT listan
att någon kolumn i INSERT listan har en annan typ än den kolumnen som är på samma position i SELECT listan
att en kolumn från SELECT listan läggs in i fel kolumn i INSERT tabellen

Eftersom felmeddelandet inte alltid pekar ut vilken rad som innehåller ett fel så kan det bli ganska tidsödande att hitta felet, speciellt om det är så enkelt som att man missat ett kommatecken mellan två kolumner eftersom det då anses vara ett alias på grund av att AS är inte obligatoriskt!

INSERT INTO dbo.yyy (createdDate)
SELECT GETDATE() createdDate FROM xxx

är detsama som

INSERT INTO dbo.yyy (createdDate)
SELECT GETDATE() as createdDate FROM xxx

MEN vad hade hänt anta att du hade velat ha en currentTime baserat på GETDATE() och en kolumn från xxx som heter createdDate. I nedanstående exempel har jag medvetet "missat" ett kommatecken för att visa konsekvensen. GETDATE() får ett alias som heter createdDate och antalet kolumner i INSERT matchar inte antalet i SELECT, vilket resulterar i ett fel.

INSERT INTO dbo.yyy (currentTime, createdDate)
SELECT GETDATE() createdDate FROM xxx

Det här felet hade inte uppstått om vi hade varit tvungen att skriva AS för alias. Det har var dock ett enkelt exempel där det var lätt att se var felet uppstod, men vi har nog alla sett många exempel på svårläst kod så jag undviker att tråka ut er med en sådan.

Nu till ett alternativ som inte är ANSI compliant, men som jag är förespråkare till:

alias = uttryck

Så här skriver man ju i de flesta andra programmeringsspråk, så varför inte i SQL!

INSERT INTO dbo.yyy (currentTime, createdDate)
SELECT currentTime = GETDATE() createdDate FROM xxx

Det är lätt att följa och lätt att matcha SELECT satsen visuellt mot INSERT satsen. Samma kolumnnamn i INSERT listan som i SELECT listan och aliaset står först så att det inte försvinner längst bort i perifirin. Det spelar då ingen roll hur långt uttrycket blir:

INSERT INTO dbo.zzz ( customerID, CountryCode)
SELECT
customerID,
countryCode = CASE countryName
                                WHEN 'SWEDEN' THEN 'SE'
                                WHEN 'Sverige' THEN 'SE'
                                WHEN 'NORWAY' THEN 'NO'
                                WHEN 'FINLAND' THEN 'FI'
                      END
FROM dbo.bbb

är lättare att läsa och följa än:

INSERT INTO dbo.zzz (customerID, CountryCode)
SELECT
customerID,
CASE countryName
                                WHEN 'SWEDEN' THEN 'SE'
                                 WHEN 'Sverige' THEN 'SE'
                                WHEN 'NORWAY' THEN 'NO'
                                WHEN 'FINLAND' THEN 'FI'
END AS countryCode
FROM dbo.bbb

Orolig för att det inte är ANSI standard? Personligen så har jag inte sett så många bra tillämpningar som är helt plattformsoberoende och kan porteras mellan olika databasmotorer utan att det finns några problem, framförallt vad gäller prestanda.

Läs gärna mer om Alias ifrån Aaron Bertrand på http://sqlblog.com/blogs/aaron_bertrand/archive/2012/01/23/bad-habits-to-kick-using-as-instead-of-for-column-aliases.aspx

Kontakta gärna någon av våra SQL server konsulter för att få hjälp att sätta upp en Best Practice för SQL server

Guest Blog: Performance Tip - Transactions Can Actually Boost Throughput

SQL Service are happy to welcome Michael K Campbell as a guest blogger! Michael K Campbell (mike@sqlserveraudits.com and www.sqlserveraudits.com) is a contributing editor for SQL Server Magazine and a consultant with years of SQL Server DBA and developer experience. He enjoys consulting, development, and creating free videos for www.sqlservervideos.com.

Over to you Michael!

************************************

Good developers typically have a good handle on what Donald Knuth’s famous quote about “premature optimization [being] the root of all evil” is all about – it’s a constant reminder that developers shouldn’t needlessly agonize over every line of code and worry about its potential performance cost. Instead, they should code as necessary (using as many best practices as possible), and then come BACK and manage any performance tuning needed – once their application is put under load.

Still, one area where seasoned developers typically tend to be a bit worried or leery about potential performance problems is when it comes to explicit transactions – because any seasoned developer knows that transactions come with a certain amount of processing overhead and an increase in resource utilization.

Explicit Transactions Can Actually Make SOME Operations Faster

As such, it can come as a big surprise to many developers that there are actually SOME kinds of operations that you can actually SPEED up in SQL Server when you wrap them within explicit transactions. And the key to gaining a sense for how all of this works is to remember that the SQL Server Transaction Log has to keep writing out changes, serially, as each and every data modification comes through. Consequently, if a large number of UPDATE, for example, or INSERTs, is fired off – one after another, that means that the Transaction Log is going to be hit by a bunch of back-to-back, individual and distinct, operations that can each be rolled back, independently, if needed.

Of late, I’ve spent a decent amount of time working with a couple of different clients to help diagnose potential problems with multi-tenant servers – where large numbers of transactions can have an ugly ‘aggregate’ effect when there are lots of writes being sent to multiple databases at the same time. Accordingly, one of the things I’ve been paying attention to a lot of late is the SQL Server Log Manager and how it works – including how it buffers data and so on. And, along those lines, I was reminded of the fact that in SOME cases, explicitly blocking lots of (typically repeated) operations into a single, explicit, transaction can actually do a lot of good in terms of reducing disk-activity generated by the transaction log.

Proof is in the Pudding - Or: Only Attempt this with Appropriate Testing

Granted, this isn’t something you’d necessarily believe without seeing some hard numbers to back up such a claim NOR is it something you’d want to blindly consider for all operations without checking the actual metrics as well. So, with that in mind, let’s look at some examples.

To do that, you’ll want to carve out a little sandbox for yourself – somewhere in a NON-production database. For me, that’s my ‘Meddling’ database, which, as you can see, I start of with by creating a new table, and then running some backups to make sure I can clear out any transactions in the transaction log:

USE Meddling

GO

IF OBJECT_ID('dbo.TransactionTest','U') IS NOT NULL

        DROP TABLE dbo.TransactionTest

GO

CREATE TABLE dbo.TransactionTest (

        RowId int IDENTITY(1,1) NOT NULL,

        OptionName nvarchar(40) NOT NULL,

        OptionValue int NOT NULL

GO

BACKUP DATABASE Meddling TO DISK = N'D:\SQLBackups\Meddling_Full.bak'

WITH COMPRESSION

GO

BACKUP LOG Meddling TO DISK = N'D:\SQLBackups\Meddling_FULL.trn'

WITH COMPRESSION

GO

Then, once I’ve created a table and cleared everything out, I can check on the amount of space being used in my transaction log. The documented, or supported, way to do this is to use DBCC SQLPERF() command with the LOGSPACE argument, but I personally hate how that shows me log-space info for all tables. (Er, well, I hate that aspect when working on a single database – especially when I have a lot.) So, I prefer to use an admittedly ugly way of getting the same info – by using performance counters:

SELECT

        dbs.name,

        ls.cntr_value / 1024 AS [Log Size (MB)],

        lu.cntr_value / 1024 AS [Log Used (MB)]

FROM

        sys.databases dbs

        INNER JOIN sys.dm_os_performance_counters lu ON dbs.name = lu.instance_name

        INNER JOIN sys.dm_os_performance_counters ls ON dbs.name = ls.instance_name

WHERE

        lu.counter_name LIKE N'Log File(s) Used Size (KB)%'

        AND ls.counter_name LIKE N'Log File(s) Size (KB)%'

        AND dbs.database_id = DB_ID()

As the benefit of such an approach is that it’s pretty easy to restrict results down to a single database.

And, in my case, after a t-log backup, I’m using roughly 4MB of my 100MB log. And, with such a base-line set, I can then kick off a pretty simple operation where I’ll log 20,000 back to back inserts by creating some bogus data from the master’s spt_value table (something that’s really only good for demos):

SET NOCOUNT ON

GO

DECLARE cursorsAreUgly CURSOR FAST_FORWARD

FOR

        SELECT TOP 20000 t1.name, t1.number

        FROM master.dbo.spt_values t1

                 LEFT JOIN master.dbo.spt_values t2 ON t1.number = t2.number

                 LEFT JOIN master.dbo.spt_values t3 ON t2.name = t3.name

                 LEFT JOIN master.dbo.spt_values t4 ON t3.name = t1.name

        ORDER BY NEWID()

DECLARE @name nvarchar(40), @number int

OPEN cursorsAreUgly

FETCH NEXT FROM cursorsAreUgly INTO @name, @number

WHILE @@FETCH_STATUS = 0 BEGIN

        INSERT INTO TransactionTest

        VALUES (ISNULL(@name,''), @number)

        FETCH NEXT FROM cursorsAreUgly INTO @name, @number

END

CLOSE cursorsAreUgly

DEALLOCATE cursorsAreUgly

GO

And, while 20,000 INSERTs may seem like a lot (and is), these are exceptionally narrow rows – so bear that in mind when comparing this technique against your own data.

Likewise, in my example, I’m using a cursor – but your code might be processing either INSERTs or UPDATEs much differently.

The key thing, though, is that after running that statement above (which takes 13 seconds on my dev/testing server that runs older/cruddy SATA drives), I end up with 13MB of my log file used.

If, however, I re-backup the transaction log (to clear it out – and get back down to around 4MB used), and then run the following operation – which wraps everything in an EXPLICIT transaction (something that might make you think this operation would take LONGER than the implicit version listed above) :

SET NOCOUNT ON

GO

BEGIN TRAN

        DECLARE cursorsAreUgly CURSOR FAST_FORWARD

FOR

                 SELECT TOP 20000 t1.name, t1.number

                 FROM master.dbo.spt_values t1

                         LEFT JOIN master.dbo.spt_values t2 ON t1.number = t2.number

                         LEFT JOIN master.dbo.spt_values t3 ON t2.name = t3.name

                         LEFT JOIN master.dbo.spt_values t4 ON t3.name = t1.name

                 ORDER BY NEWID()

        DECLARE @name nvarchar(40), @number int

        OPEN cursorsAreUgly

        FETCH NEXT FROM cursorsAreUgly INTO @name, @number

        WHILE @@FETCH_STATUS = 0 BEGIN

                  INSERT INTO TransactionTest

                 VALUES (ISNULL(@name,''), @number)

                 FETCH NEXT FROM cursorsAreUgly INTO @name, @number

END

        CLOSE cursorsAreUgly

        DEALLOCATE cursorsAreUgly

COMMIT

GO

I end up with an operation that only took 8 seconds, and which only managed to generate an additional 3MB of transaction log usage (taking me up to 7MB used total instead of 13MB – quite a nice savings). And, of course, if I watch disk performance counters, I can see that they’re the primary source of contention during the previous operation – or they end up being my bottleneck because I’m thumping them over and over and over again.

In fact, if you’d like to get a better insight into what’s going on, run the tests above in your own environment and pay attention to your disk metrics AND take a peek at what’s being logged to the T-LOG itself by means of the most-excellent, and undocumented, T-SQL functionality made available by fn_dblog() as follows:

SELECT * FROM fn_dblog(NULL, NULL)

And, just make sure that you backup your t-log between each of your tests – to clear out used data and to make it easier to see the differences in what’s going on by looking at fn_dblog() output.

Conclusion

Obviously, this blog post isn’t an open invitation to run out and wrap every single operation in an explicit transaction. Instead, it’s a reminder that when you know what’s going on under the covers, performance benefits and boosts can come in what might, otherwise, seem to be surprising ways. That, and this post is a reminder that testing and hard-numbers are a great way to ensure performance optimizations when they’re actually needed.

Dubbla index ?

Vad som ofta förvånar oss när vi är ute hos kunder är de index som eventuellt är skapade för tabellerna. Att skapa rätt index är en konst och på samma sätt som det kan förbättra kan det också försämra och t.ex. tynga ned ett system som kostar i det extra underhåll som krävs. Det är ju väldigt lätt att skapa index i SQL Server och man får inte heller mycken hjälp ens av de verkyg som följer med t.ex. Database Tuning Advisor. Visst kan liknande verktyg hjälpa till att ge förslag på index men man skall aldrig lita blint på dessa råd och sedan skapa alla möjliga och omöjliga index. Bättre är då anlita experter och skapa de nödvändiga och rätta index. De allra bästa är förstås att en gång för alla verkligen lära sig detta med att skapa index. Självklart hjälper vi till med både och. Detta är en investering som kommer löna sig i det långa loppet.

Som sagt ett exempel som kan finnas är dubbla index, dvs index som täcker samma kolumner . Rätt smart att ha två innehållsförteckningar i samma bok :-).

Nedan finns en länk med informaton som avslöjar om detta är fallet i eran miljö.

http://www.sqlskills.com/BLOGS/KIMBERLY/post/UnderstandingDuplicateIndexes.aspx

Find the code behind

-- If you need to split strings on specific characters
-- and experiencing problem finding the right character
-- or the UNICODE code of the character this might come in handy.
--
-- The reason behind this post is that I needed to identify the character code

-- behind a junk character.

--
-- It utilizes a cursor because I need to loop through the string or strings.
-- The cursor fetch every single string, and the loop reads the string.
--
-- Valiables for the string
DECLARE @string nvarchar(255) = N'', @stringnumber int = 0, @length int = 0

-- Declaring the cursor
DECLARE StringCursor CURSOR FOR
-- Within the block comment you'll find a sample query.
-- * {rowidentifier} = The column that identifies the row in table
-- * {stringcolumn} = The column that needs to be evaluated
-- * {sourcetable} = The table that contains your strings
-- * {filtercolumn} = The column that identifies your row containing the string
-- * {filtervalue} = The value that filter
/*
SELECT {rowidentifier}, {stringcolumn} FROM {sourcetable} WHERE {filtercolumn} = {filtervalue}
*/
-- Just to get some sample data.
SELECT
ROW_NUMBER() OVER (ORDER BY (SELECT NULL)),
name
FROM sys.databases (NOLOCK)
-- Please note that ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) is
-- just something that gives you the read order position of the string
-- and should probably be a reference to the row identifier.

-- A variable containg the target table
DECLARE @StringTable TABLE (
String nvarchar(255) NOT NULL,
-- String to be evaluated
StringNumber int NOT NULL,
-- Number representing the physical order in table
Position int NOT NULL,
-- Position in string for the Character
UNICODECharacter nchar(1) NOT NULL,
-- Character to be decoded
UNICODECode AS UNICODE(UNICODECharacter)
-- The UNICODE for specific character.
)

-- In this example I use a cursor. Remember that cursors might be bad
-- and if the source table contain long words and long strings this might take
-- a while. Due to this I choose to add the NOLOCK hint on the query for the cursor.
OPEN StringCursor
FETCH NEXT FROM StringCursor INTO @stringnumber, @string

WHILE @@FETCH_STATUS = 0
-- As long the FETCH NEXT grabs a row this is true.
BEGIN

-- Variables for the position of the character and character itself.
DECLARE @pos int = 1, @char nchar(1) = N''
SET @length = LEN(@string)
-- Length of the evaluated string.
WHILE @pos -- Will continue to loop while we have a character to read.
BEGIN
-- Inserts the table valued variable
INSERT INTO @StringTable (String, StringNumber, Position, UNICODECharacter)
VALUES(@string, @stringnumber, @pos, SUBSTRING(@string, @pos, 1))
SET @pos += 1
-- Moves to next position in the string.
END
-- Grab the next string from the table.
FETCH NEXT FROM StringCursor INTO @stringnumber, @string
END

-- The CLOSE and DEALLOCATE is important and usually forgotten and if left out
-- probably leads to excessive, unnecessary locking.
CLOSE StringCursor
DEALLOCATE StringCursor

-- See the result.
SELECT * from @StringTable

-- Have fun, I hope you enjoyed the script.
-- /Mattias

SQL Server - DataDictionary

Som SQL server konsult så har jag under min karriär ofta stött på databaser som saknar ett vettigt (och konsekvent) data dictionary. Avsaknaden av data dictionary tar sig ofta uttryck i databaser som innehåller tabeller med olika definitioner för samma verksamhetsbegrepp (realiserat som kolumner).

Det kan i första anblick tyckas oviktigt att ha samma definition för samma begrepp i olika tabeller, men tittar man närmare på problemet så kan man hitta ganska allvarliga konsekvenser av detta.

Några av de allvarliga negativa konsekvenserna kan vara:

trunkering av data
exceptions
implicit conversion, med prestandaproblem som följd

Att samma verksamhetsbegrepp förekommer i flera olika tabeller kan dessutom vara ett tecken på dålig databasdesign.

Exempel på problemet:

CREATE TABLE dbo.x(ID int IDENTITY(1,1),Val NUMERIC(4,2),NAME CHAR(10),ModificationDate DATETIME2 DEFAULT(GETDATE()));GO
CREATE TABLE dbo.y(ID int IDENTITY(1,1),Val NUMERIC(4,2),NAME VARCHAR(30),ModificationDate DATETIME DEFAULT(GETDATE()));GO
CREATE NONCLUSTERED INDEX ix_x ON dbo.x(ModificationDate)INCLUDE(val) ;GO
CREATE NONCLUSTERED INDEX ix_y ON dbo.y(ModificationDate)INCLUDE(val) ;GO

CREATE PROCEDURE dbo.getByModDate @ModificationDate DATETIME2
AS
PRINT @ModificationDate;

SELECT val FROM dbo.x WHERE ModificationDate=@ModificationDate;
SELECT val FROM dbo.y WHERE ModificationDate=@ModificationDate;
SELECT x.val,x.ModificationDate,y.val,y.ModificationDate FROM dbo.x INNER JOIN dbo.y ON dbo.y.ModificationDate=dbo.x.ModificationDate ;
GO

DECLARE @date DATETIME2=SYSDATETIME();
INSERT INTO dbo.x(Val,name,ModificationDate) VALUES(10.01,'H.Winther',@date);
INSERT INTO dbo.y(Val,name,ModificationDate) VALUES(10.01,'H.Winther',@date)
EXEC dbo.getByModDate @ModificationDate=@date

I det här exemplet så kommer proceduren att bara returnera 1 enda rad eftersom det sker implicita konverteringar och i dessa konvertingar så försvinner precisionen på tidsangivelsen vilket gör att det inte blir någon träff.

Problemet hade lätt kunnat undvikas om man hade gjort en ordentlig modellering av verksamhetsbegrepp och omsatt det till ett DataDictionary som kan användas för att validera datamodellen.

För att underlätta denna typ av validering så har SQL service tagit fram ett DataDictionary verktyg. Alla kolumner eller parametrar som inte finns i DataDictionary tabellen eller inte matchar datatypen kommer att rapporteras som ogiltiga.

Om du redan har en färdig/halvfärdig databas så kan du använda vårt verktyg för att samla in alla kolumner samt dess definition och lagra dem som verksamhetsbegrepp. Information om vilka tabeller som använder verksamhetsbegrepp lagras i en länkad tabell tillsammans med dess definition.

Är du intresserad av att veta mer om DataDictionary och vårt DataDictionary verktyg så är du varmt välkommen att kontakta någon av våra SQL server konsulter

Job Schedules

När man väljer att schemalägga ett jobb i SQL Server så har man möjlighet att välja en tid som redan är definerad mha "Pick". Det som då kan hända är att man väljer att ändra en tid och inte tänker på att det kanske finns andra jobb som också använder denna tid. Detta inträffar också om man kopierar ett jobb. Titta i exemplet nedan.

TestJob1 har tiden 06:00

Sedan tar tar man och ändrar tiden för TestJob2 till 06:30 och till och med döper om det till "Daily 06:30".

Kanske inte helt oväntat men troligen inte vad man vill är att nu har ju tiden ändrats också för TestJob1.

Nu finns det ju ett sätt se hur många jobb som använder samma schemaläggningsrad och det är mha "Pick". Däremot ser man inte informationen för det jobb man står på utan man måste välja ett annat som nedan.

SQL Server 2012 support in System Center Advisor

This does not really qualify as news, but it is worth mentioning that System Center Advisor http://www.systemcenteradvisor.com/ (More info here http://www.sqlservice.se/sv/start/blogg/atlanta-a-k-a-system-center-advisor.aspx and here http://onlinehelp.microsoft.com/en-us/advisor/default.aspx) supports monitoring SQL Server 2012 since April 2012. If you haven't yet tried it out, now might be the time! System Center Advisor is a cloud based SQL Server (and more...) daily monitoring tool, that analyzes your environment and gives you information about issues that you have to of want to fix, to avoid potential problems. And if you have SQL Server with Software assurance, you have already paid for it!

SQL Server support livscykel

Att Microsoft inte supportar sina produkter och versioner av dessa i all evighet vet vi alla. Som ni kanske också vet så gäller detta även alla service packar. Tex så supportar Microsoft sina service packar 12 månader efter att nästföljande service pack släpps.

Det är viktigt att ha koll på detta så man inte kör på en osupportad version. Risken med att halka efter är att man inte får hjälp den dagen man verkligen behöver hjälp. I värsta fall kan man då tvingas göra en uppgradering innan man kan komma vidare i felsökningen eller få hjälp av Microsoft. Bättre då att istället ligga steget före och uppgradera när nya service packar släpps under kontrollerade former.

Dessutom är ju service packar en uppdatering och förbättring av programvaran vilket man naturligtvis vill ha!

Lyckligtvis behöver man inte memorera alla datum då versioner och uppdateringar av versioner blir osupportade, man kan titta här:

http://support.microsoft.com/lifecycle/?LN=en-us&x=5&y=11&c2=1044

Where is my data?

As you might already know, SQL Server stores the data in the databases in *.mdf and *.ndf files. And internally, these files are divided up into 8Kb structures called Pages. And sometimes you might want to know exactly in which file and which page a certain row of data is stored.

Why would you ever need to know that, apart from pure curiosity? One example could be to verify how many rows you can fit on one page with you current database design, and maybe how designchanges affects this. And it can also be a good way to visually see the fragmentation of your clustered indexes. Or even to view the effects of converting a heap to a table with a clustered index.

Let me show you how this can be done, using MSDB as an example database:

Select jh.*, pl.* from msdb.dbo.sysjobhistory jh

Cross apply fn_physloccracker(%%physloc%%) pl

This gives us all rows and all columns in the sysjobhistory table, and 3 additional columns to the right of the normal columns:

File_ID is the id number of the mdf/ndf datafile.

Page_ID is the id of the 8Kb page that the specific row is stored on

Slot_ID is the ordinal place in the page that this specific row is stored on, as a page can generally contain several rows.

Behörighet på radnivå i SQL Server

Det finns ingen inbyggd funktionalitet i SQL Server för att sätta behörighet på radnivå utan enbart på tabellnivå. Det finns inte heller i den nyaste versionen SQL Server 2012 något stöd för radsäkerhet, alltså stöd för vilka poster som de olika användarna skall se. Dock finns det på förslagslistan till förbättringar, men tydligen prioriteras inte detta nog mycket. Däremot finns det vedertagna sätt för att lösa behovet av radsäkerhet som jag här i korthet beskriver.

För att adminstrera behörighet på radnivå så lägger man till några administrationstabeller och definerar nivåer av säkerhet som man önskar. Detta gör man enklast med ett verktyg ”Label Policy Designer” som är utvecklat av Microsofts team ”Consulting Services”.

Nedan är en bild av hur nivåerna kan se ut.

När definitionen av säkerheten och dess nivåer är uppsatt i detta verktyg så väljer man därefter databas och implementerar denna design i databasen. Det som då händer är att fem tabeller skapas och fylls med poster för att stödja designen man gjort av behörigheterna. Dessutom skapas vyer, funktioner och roller i den valda databasen. Tanken är nämligen att istället för att ge behörighet till tabellerna så använder man vyer som styr vilka rader ur tabellerna de olika användarna ser. Detta innebär att alla tabeller som skall ha radbehörighet måste kompletteras med en kolumn, t.ex. RLS_ID som sedan fylls med rätt behörighetsnivå . Det kan då se ut som nedan.

DECLARE @SECRET int exec usp_GetSecLabelID '<Label><Cl>SECRET</Cl></Label>', @SECRET OUTPUT

INSERT INTO tblCustomer (Name, Phone, Email, RLS_ID) VALUES ('Catherine R. Abel (AdvWorks)', '(888) 555-4433', 'catherine0@adventure-works.com', @SECRET)

Dessutom måste roller tilldelas till de olika användarna som t.ex. nedan.

exec sp_addrolemember 'clSECRET', 'Bob'

Som sagt kommer vyer användas av användarna istället för direkt gå mot tabellerna. Nedan ser man ett typiskt exempel på hur en vy ser ut.

CREATE VIEW Customer WITH ENCRYPTION, VIEW_METADATA AS

SELECT tblCustomer.ID, Name, Phone, Email

FROM tblCustomer WITH (READCOMMITTED) INNER JOIN vwVisibleLabels ON tblCustomer.RLS_ID = vwVisibleLabels.ID

Allt detta innebär i slutändan att användarna beroende på sin behörighet får olika resultat på denna fråga:

SELECT [Name], [Phone],[Email] FROM [dbo].[Customer]

En användare kan då få detta resultat:

Medan en annan användare som har ”mer” behörighet får detta resultat:

Mer information hittar ni i denna artikel

http://technet.microsoft.com/en-us/library/cc966395.aspx

SQL Server Label Security Toolkit hittar ni här.

http://sqlserverlst.codeplex.com/

Viewing the output of any SQL Server SPID

When investigation problems whit SQL Server, we often use commands like DBCC INPUTBUFFER, or tools like SQL Server Profile to view the various commands that arrive to SQL Server, thereby finding useful information such as errors, duration, CPU usage, IO usage and so on.

But, what if you don't want to see what query the client sent to SQL Server but rather the result that SQL Server sent back to the client? That is not as easy as using Profiler, but can be done. Sort of.

The command to use is DBCC OUTPUTBUFFER (SPID ,[otional request id]) . Full documentation of this command is at http://msdn.microsoft.com/en-us/library/ms189821.aspx

The drawback is that you can only see the curent outputbuffer, not a continous stream as with Profiler for input. But if you know the SPID of the problematic connection/application you can atleast see what the last results or messages returned to it looks like.

And you could create a little loop like this to collect info for a little bit of time, and the view it.

create table #tmp (output varchar(max))

declare @buf int=0

while @buf< 100

begin

insert into #tmp exec ('dbcc outputbuffer (83)')

select @buf = @buf +1

end

select * from #tmp

drop table #tmp

24 Hours Of Pass - 2012

Som vanligt finns möjlighet att få ett smakprov på några av sessionerna som kommer under Pass Summit i Seattle 5-9 november. Detta sker om en månad, nämligen 20/9 med start kl 14.00 då man kan följa 24 sessioner. Förstås handlar det denna gång mycket om SQL Server 2012 och Azure, men även felsökning, exekveringsplaner och t.ex. "What are the Largest SQL Server Projects in the World?" kan man följa under 24 timmar.

Regstreringen gör man här:

http://www.sqlpass.org/24hours/fall2012/SessionsbySchedule.aspx

SQL server indexing strategies part 3 - non clustered indexes

This is my third blog post about indexing strategies for SQL server and it has passed some time since the last one, but now it's time for the next.

In SQL server 2005, Microsoft implemented something called included columns, and although it's more than 7 years since SQL server 2005 was brought to life, I still get the questions:

What is an included column?
Why do I need included columns?
How should I use included columns?

I think it is time to repeat the answers and give some kind of explanation.

First of, lets explain the difference between the clustered and the non clustered index in a simple way. Think of a book with an index. The index of the book give you a structured way of finding the right page to read. A clustered index is like a book, you have the pages with all the information and you have an index pointing at the correct page.

You can seek the index to find the page or you can scan all the pages to get what you want, but you can only seek the index by the key columns. If you don't have any values to search for in the key columns, you have to scan the pages.

The non clustered index is more like a quick reference card where you have some other key columns in the index, but the non clustered index doesn't have the complete information in the pages. The pages in the non clustered index contains the clustered index keys AND the INCLUDED COLUMNS.

By searching the non clustered index, you'll only find the key words you need to search the clustered index to get the rest of the information.

Assume you want to get all columns for a customer record and the clustering key in the clustered index is a counter. You probably do not know the value of the counter for a specific record, but you know the customer name. To get some performance in the query you add non clustered index on customer name.

Let't take a look at some code:

CREATE SCHEMA SALES GO

CREATE TABLE [Sales].[Customer](
[ID] [int] IDENTITY(1,1) NOT NULL,
[CustomerName] [varchar](75) COLLATE Finnish_Swedish_CI_AS NOT NULL,
[CustomerGroup] [int] NULL,
[CustomerType] [int] NULL,
CONSTRAINT [PK_Customer] PRIMARY KEY CLUSTERED ( [ID] ASC ))
GO

CREATE NONCLUSTERED INDEX ix_Customer_AK ON Sales.Customer ( CustomerName )
GO
INSERT INTO Sales.Customer(CustomerName,CustomerType) VALUES('Håkan Winther', 1),('SQL Service', 2)

-- First select
SELECT * FROM Sales.Customer WHERE CustomerName='Håkan Winther'

DROP INDEX ix_Customer_AK ON Sales.Customer;
GO

CREATE NONCLUSTERED INDEX ix_Customer_AK ON Sales.Customer ( CustomerName )INCLUDE(CustomerType) GO

-- second select
SELECT ID,CustomerName,CustomerType FROM Sales.Customer WHERE CustomerName='Håkan Winther'
-- the third select
SELECT ID,CustomerName,CustomerType FROM Sales.Customer WHERE CustomerType=1

If you take a look at the actual execution plan you can see something interesting. The first select using select * cannot get all the information from the nonclusterd index and needs to go to the clustered index to get all columns. It can be done in tw ways, a clustered index scan or an index seek + a key lookup. Either way, this will not give you the best performance.

In the second select you'll get all the columns you need from the nonclustered index as Clustering key (ID) is always included in all non clustered indexes and CustomerType is specified in the include clause. In the execution plan, you'll find an index seek on the non clustered index. This is what's called covering index.

As you can see in the third select, you'll get an index scan in the non clustered index as CustomerType is not one of the index keys, it's only included at the "page" level.

You might ask yourself, why don't I use all columns as key columns in the index. Well there are some limitations, like you can't have more than 16 columns as key columns and you'll lose performance.

>>Conclusion<<

You need included columns to get the performance when you need to search on columns that is not part of the clustered index, by avoiding clustered index scans and index seek + key lookup.

Well, I hope you learned something from this blog post or that it was crystal clear from the beginning.

SQL server indexing strategy part1 - General recommendations

When you design a database you should have performance in mind, and indexing strategy is one of the important things to consider. If you create too few or to many indexes you'll suffer from bad performance. If you don't have indexes to cover your queries, you'll have slow running queries, and if you have to many, your inserts, updates and deletes will be slow. You have to balance this and there are always tradeoffs and there are no simple answers that will work for everybody, but there are some guidelines you can follow.

In this series of blog posts I'll try to give you some of these guidelines.

- Don't create too many or too few.
- Every table should have a clustered index! End of discussion! (some might say that small tables shouldn't have, but I'll cover that in a later post)
- Choose the clustered index wisely, don't let SQL Server Management Studio to select it for you (by creating a primary key in the table designer.
- Index columns that is used in a foreign key relation
- Test you workload with your indexes
- Monitor your performance to find new indexes
- Remove indexes that is not used
- Don't create duplicate indexes
- The column order in you index counts, if the first column in the index is not used in a where/join clause, you'll end up with a scan
- Use the right fill factor for every index, don't count on the server default setting for fillfactor
- Consider partitioning for performance and maintenance
- Use data compression for datawarehouse/reporting databases.
- Rebuild the indexes on a regular basis
- Update the statistics of the indexes

Get back another day for more details on specific recommendations

If you have some questions, feel free to contact any of our SQL server consultants and we will help you.

Just a brief demo of dynamic use of OFFSET through a loop

DECLARE	-- Let us declare variables:
@count int = 0,	-- Start
@to int,	-- End
@rows int = 10;	-- Rows per set
SELECT	-- Now we're gonna
@to = count(*) / @rows	-- determe the number of sets
FROM sys.columns	-- from this table
WHILE @count <= @to	-- This loops all through to the last set
BEGIN
SELECT	-- Returning these
*	-- columns
FROM sys.columns	-- from this table
ORDER BY 1 ASC	-- in this order (here just based on first column).
OFFSET (0 + (@count * @rows))	-- Based on loop we get the starting point of the offset.
ROW FETCH NEXT (@rows) ROWS ONLY	-- The number of rows we're fetching!
SET @count += 1	-- Next step!
END

En liten PIVOT

Hej på er,

Nu när det gått en vecka tänkte jag passa på att presentera mig. Mattias Lind heter jag och började den 1:a augusti här på SQL Service. De senaste tio åren har jag kört som egenföretagare, min profil som talare, instruktör, mentor och konsult gäller fortfarande, dock numera som en i ett fantasktiskt team här hos SQL Service.

Sedan tänkte jag också dela med mig lite av mina erfarenheter i den här bloggen, min personliga blog http://blog.mssqlserver.se lever givetvis kvar även fast också jag skriver här med jämna mellanrum. Till att börja med så tänkte jag visa er hur PIVOT kan fungera i verkligheten på ett lite mer dynamiskt sätt. Ofta när jag håller kurser får jag frågan hur jag skulle ha gjort, här kommer jag att skriva inlägg som svar på de frågorna.

Men innan vi börjar behöver vi lite data. Jag tänkte att resultatet skulle vara en pivottabell över våran databas server, där varje databas får en rad och typen av databasobjekt blir kolumner och antalet av de här objekten blir en summa. Med de förutsättningarna skapar vi först en tabell som en variabel, därefter fyller vi den tabellen med metadata med hjälp av en cursor.

-- Först skapar vi en tabellvariabel samt deklarerar lite variabler vi behöver
DECLARE @DatabaseObjects TABLE
  (
    DatabaseName sysname,
    ObjectType sysname,
    ObjectName sysname
);
DECLARE
  @DatabaseName sysname,
  @SQLStatement varchar(max),
  @ExecuteStatement varchar(max),
  @Columns varchar(max);

-- Här börjar laddningen av simulerat data
SET NOCOUNT ON;
SET @SQLStatement = 'SELECT ''{DatabaseName}'' AS [DatabaseName], [type_desc] AS [ObjectType], [name] AS [ObjectName] FROM [{DatabaseName}].[sys].[objects];';
DECLARE
  DatabaseCrawler CURSOR
  FOR SELECT Name FROM sys.Databases ORDER BY Name ASC;
OPEN DatabaseCrawler;
FETCH NEXT FROM DatabaseCrawler INTO @DatabaseName;
WHILE @@FETCH_STATUS = 0
BEGIN
  SET @ExecuteStatement = REPLACE(@SQLStatement, '{DatabaseName}', @DatabaseName);
  INSERT INTO @DatabaseObjects
  EXEC (@ExecuteStatement);
  FETCH NEXT FROM DatabaseCrawler INTO @DatabaseName;
END;
CLOSE DatabaseCrawler;
DEALLOCATE DatabaseCrawler;
SET NOCOUNT OFF;

-- Först skapar jag en temporär tabell eftersom tabellvariabeln inte kan nås i kommande EXEC-uttryck
SELECT * INTO #DatabaseObjects FROM @DatabaseObjects

-- Sedan populerar jag en variabel med en kommaseparerad lista av unika objektstyper
SELECT @Columns = ISNULL(@Columns, '') + '[' + [Column] + '],' FROM (SELECT DISTINCT ObjectType AS [Column] FROM @DatabaseObjects) Columns

-- Därefter tar jag bort det avslutande kommatecknet i listan
SET @Columns = LEFT(@Columns, LEN(@Columns) - 1)

-- SELECT-uttrycket med PIVOT-klausulen, {Columns} är en platshållare. Den återkommer två gånger.
SET @SQLStatement = 'SELECT DatabaseName, {Columns} FROM #DatabaseObjects PIVOT (Count(ObjectName) FOR ObjectType IN ({Columns})) AS pvt'

-- Ersätter platshållaren med innehållet i listan.
SET @ExecuteStatement = REPLACE(@SQLStatement, '{Columns}', @Columns);

-- Slutligen kör jag SQL-uttrycket och tar bort den temporära tabellen
EXEC (@ExecuteStatement)
DROP TABLE #DatabaseObjects

Så varför all denna kod för att få ut ett pivoterat resultat. Titta på innehållet i variabeln @SQLStatement.
    SELECT DatabaseName, {Columns} FROM #DatabaseObjects
    PIVOT (Count(ObjectName) FOR ObjectType IN ({Columns})) AS pvt
{Columns} är listan över kolumner, eftersom dessa hämtas från tabellen @DatabaseObjects och dess kolumn ObjectTypes.Om jag inte använt det här skriptet hade jag således varit tvungen att skriva in kolumnnamnen manuellt. Nu använder jag istället REPLACE-funktionen för att ersätta {Columns} med en kommaseparerad lista i variabeln @Columns.

SQL Server - cast string into date vs datetime

I found a tricky question on http://www.sqlservercentral.com/Questions about casting strings into date vs datetime, and I want to share this with you, in case you missed it. (by the way, excellent site if you want to measure your knowledge and learn something new, thanks SQL server central)

Try the following code:

SET DATEFORMAT YDM;
GO

CREATE VIEW vDate(dt1, dt2)
AS
SELECT CAST('2012-04-10' AS DATETIME),CAST('2012-04-10' AS DATE
)
GO

SET DATEFORMAT YDM;
GO
SELECT * FROM vDate WHERE dt1=dt2;

SET DATEFORMAT YMD;
GO
SELECT * FROM vDate WHERE dt1=dt2;

DROP VIEW vDate;

It turns out that the two selects from the veiw doesn't return the same result! :) The string casted to datetime is depending on the regional setting but date is not. The date datatype is language neutral and will always be casted as yyyymmdd.

If you want to learn more about how date and datetime are handled by the sql server engine you can read more on Tibor Karaszi's blog http://www.karaszi.com/SQLServer/info_datetime.asp or contact any of our SQL server consultants.

Running COM objects outside SQL Server process

In some cases, you can get an error 0x00000005 (Access Violation) in the SQL Server process, that is caused by running external COM objects via sp_OAcreate. The effect is that the entire SQL server process rolls over and dies immedeately.

This can be quite hard to solve without the help of Microsoft PSS, but there is one thing you can try that might help. When you call sp_OAcreate, use option 4, wich will spawn teh COM object in a process outside the SQL server process. If and when that process crashes, atleast it will not take down the entire SQL Server process with it.

Read more about sp_OAcreate at http://msdn.microsoft.com/en-us/library/ms189763(v=sql.105).aspx

Microsoft Sommarkollo 2012 - Nyheterna i SQL server 2012

För er som missat min session på Microsoft Sommarkollo 2012 - Nyheterna i SQL server 2012, eller för er som vill gå igenom presentationen på egen hand som finns den nu för nedladdning. Sommarkollo2012_SQLserver2012.pptx

Kommer inom kort även på Microsofts hemsida.

Vill ni veta mer om SQL server 2012 så får ni gärna kontata någon av våra SQL server konsulter eller anmäla er till vår kurs på LabCenter.

/Håkan Winther

SSRS and report caching, dynamic refresh for Data Warehouses

I have a Data Warehouse, in which the data is loaded once a day and during the rest of the time the data does not change. There are several heavy reports in SSRS used to cater data to the users, and it really saves the day to cache them. The performance improvement is great, but there is one problem. I do not know exactly when the data is coming, and I need to refresh the chached report dynamically.

In SSRS there are several options for re-loading the chache of the cached reports:

- Either after N minutes, or by a schedule.

As you can see, none of these options work for me, so I looked a bit in detail in what options I have to refresh the cache manually. How do I do that?:

- There is a stored procedure in the Report Server database called:

dbo.SetChacheOptions which takes 4 parameters.

CREATE PROCEDURE dbo.SetCacheOptions

@Path             AS NVARCHAR(425),
@CacheReport      AS BIT,
@ExpirationFlags AS INT,
@CacheExpiration AS INT=NULL

- The @Path is the path to the report. I.e. /TestFolder/Report1 .
- The @CacheReport – is used to flag whether the report is cached or not.
- The @ExpirationFlags – is the option which points out the expiration type. 1 means that the Report expiration is set to N minutes (defined by the user) and 2 means that the report will expire according to a schedule (also created by a user).
- The @CacheExpiration – is used if the @ExpirationFlags are set to 1, i.e. to set the time in which the report will expire. The value is in minutes.

So, this said, let’s give some examples:

-- Clear Cache EXEC dbo.SetCacheOptions '/TestFolder/Report1',0,1
-- Recreate the report cache EXEC dbo.SetCacheOptions '/TestFolder/Report1',1,1,1440

In the first example, I just force the report to discard the cache. In the second example I am setting the chache to expire in 24 hours. Here is the question, though:

- how do I refresh the cache only after the data has been loaded in my database, given that there is a 6 hour window in which the data is loaded and the times are different every day?

This is relatively easy: first of all, we do not have to flush the cache before reloading it. Every time we execute the caching of the report, it will refresh the cache automatically and recreate it. So, in my SSIS routine which I use to load the data, I have an extra step after the data is loaded to just create the report cache like this:

-- Recreate the report cache EXEC dbo.SetCacheOptions '/TestFolder/Report1',1,1,1560

I am setting the expiration to 26 hours, just to give some tolerance for the next data load. But this does not really matter, because during the next data load I will execute the cache refresh procedure again.

/Feodor Georgiev

Logga deadlocks

Om du misstänker att du har problem med deadlocks är det något du bör ta tag i så snabbt som möjligt!

När du väl konstaterat att du faktiskt har deadlocks blir nästa steg att ta reda på mera detaljer kring dessa. Mer specifikt så vill du naturligtvis veta vilken kod som är orsaken och vilka tabeller som är inblandade.

En variant för att ta reda på mer är att starta en trace och lägga till följande events:
Deadlock graph
Lock:Deadlock
Lock:Deadlock Chain

Som vi alla redan känner till så får vi med dessa events en grafisk bild över eventuella deadlocks vilket kan vara bra hjälp när man försöker ringa in problemet.

Jag tänkte här istället slå ett slag för en annan variant och det är att starta traceflagga 1204 eller 1222. Dessa loggar all info kring deadlocks i SQL Server loggen. Man kan välja att enabla båda flaggorna eller bara en av dem om man vill. Båda levererar lite olika, men nödvändig, information för att felsöka deadlocks.

Vi kan tex ur loggen utläsa vilken process som är "deadlock victim", vilken kod som körts av båda parter i låsningen, vilken isolationsnivå vi hade mm.

Personligen föredrar jag denna framför den grafiska presentationen i Profiler när det gäller att snabbt spåra deadlocks, dessutom behöver jag inte starta och bevaka en trace utan kan i efterhand titta i loggen.

Dessa traceflaggor måste aktiveras på global nivå EX:

DBCC TRACEON(1222, -1), alternativt lägga till T1222 som en startup parameter för att säkerställa att loggning fortsätter även efter en omstart av SQL Server.

För en mer ingående förklaring av de olika alternativen:
http://msdn.microsoft.com/en-us/library/ms178104(SQL.105).aspx

Check your constraints

Sometimes you need to quickly import or delete large amounts of data. One way to make this quicker or easier is to disable all constraints, foreign keys and check constraints.

The following command will disable all constraints on a table:
ALTER TABLE [TableName] NOCHECK CONSTRAINT ALL;

Once data is imported you need to make sure the new data is valid according to the declarative rules in the database.
The following will enable all constraints on a table:

ALTER TABLE [TableName] CHECK CONSTRAINT ALL;

But wait! This command will only make sure new data is checked not the existing data!
To check already inserted data run the following:

ALTER TABLE [TableName] WITH CHECK CHECK CONSTRAINT ALL;

If you don't check existing data SQL Server will mark the constraint as not trusted and as a result of this it won't be able
to use the constraint to make a more efficient query plan.

If you want to list all check constraints and foreign key constraints that are not trusted you can query
sys.check_constraints and sys.foreign_keys views where is_not_trusted = 1.

SELECT * FROM sys.foreign_keys WHERE is_not_trusted = 1;

Bottom line: Make sure all your constraints are checked and trusted.

Get CPU utilization by database

När man analyserar och felsöker en server som innehåller flera databaser är det väldigt intressant att veta vilken av dessa databaser som förbrukar mest CPU resurser. Då använder man som reglel dmv'en dm_exec_query_stats. Problemet med informationen som då får är att den är ackumelerad sedan SQL Servern startades om. Ofta vill man istället se nuläget och då kan man använda nedanstående SQL som härstämmar från ett av Glen Berrys skript. Helt enkelt sparar man resultatet i en temptabell, väntar en tid t.ex. 1 minut, sparar resultatet i en ny temptabell och sedan jämför dessa värden, istället för att bara presentera utnyttjandet sedan servern startades om. Nedan får man båda dessa värden i procent som ger en bättre bild av verkligheten just nu.

-- Get CPU utilization by database

WITH DB_CPU_Stats AS (SELECT DatabaseID, DB_Name(DatabaseID) AS [DatabaseName], SUM(total_worker_time) AS [CPU_Time_Ms] FROM sys.dm_exec_query_stats AS qs CROSS APPLY (SELECT CONVERT(int, value) AS [DatabaseID] FROM sys.dm_exec_plan_attributes(qs.plan_handle) WHERE attribute = N'dbid') AS F_DB GROUP BY DatabaseID) SELECT ROW_NUMBER() OVER(ORDER BY [CPU_Time_Ms] DESC) AS [row_num], DatabaseName, [CPU_Time_Ms], CAST([CPU_Time_Ms] * 1.0 / SUM([CPU_Time_Ms]) OVER() * 100.0 AS DECIMAL(5, 2)) AS [CPUPercent] INTO #tmpDB_CPU_Stats_1 FROM DB_CPU_Stats WHERE DatabaseID > 4 -- system databases AND DatabaseID <> 32767 -- ResourceDB ORDER BY row_num OPTION (RECOMPILE);

WAITFOR DELAY '00:01:00';

WITH DB_CPU_Stats AS (SELECT DatabaseID, DB_Name(DatabaseID) AS [DatabaseName], SUM(total_worker_time) AS [CPU_Time_Ms] FROM sys.dm_exec_query_stats AS qs CROSS APPLY (SELECT CONVERT(int, value) AS [DatabaseID] FROM sys.dm_exec_plan_attributes(qs.plan_handle) WHERE attribute = N'dbid') AS F_DB GROUP BY DatabaseID) SELECT ROW_NUMBER() OVER(ORDER BY [CPU_Time_Ms] DESC) AS [row_num], DatabaseName, [CPU_Time_Ms], CAST([CPU_Time_Ms] * 1.0 / SUM([CPU_Time_Ms]) OVER() * 100.0 AS DECIMAL(5, 2)) AS [CPUPercent] INTO #tmpDB_CPU_Stats_2 FROM DB_CPU_Stats WHERE DatabaseID > 4 -- system databases AND DatabaseID <> 32767 -- ResourceDB ORDER BY row_num OPTION (RECOMPILE);

SELECT #tmpDB_CPU_Stats_1.DatabaseName, #tmpDB_CPU_Stats_1.CPUPercent,

CAST((#tmpDB_CPU_Stats_2.CPU_Time_Ms - #tmpDB_CPU_Stats_1.CPU_Time_Ms) * 1.0 / SUM((#tmpDB_CPU_Stats_2.CPU_Time_Ms - #tmpDB_CPU_Stats_1.CPU_Time_Ms)) OVER() * 100.0 AS DECIMAL(5, 2)) AS [Current_CPUPercent] FROM #tmpDB_CPU_Stats_1 INNER JOIN #tmpDB_CPU_Stats_2 ON #tmpDB_CPU_Stats_1.DatabaseName = #tmpDB_CPU_Stats_2.DatabaseName ORDER BY #tmpDB_CPU_Stats_2.CPU_Time_Ms - #tmpDB_CPU_Stats_1.CPU_Time_Ms DESC

DROP TABLE #tmpDB_CPU_Stats_1 DROP TABLE #tmpDB_CPU_Stats_2

SQLug.se challenge 2012 avgjord

Grattis säger vi och lyfter på hatten på för vår gästbloggare Christian Janssen som nu också kan titulera sig Svenska Mästare i SQL Server utveckling. Förutom Christian placerar sig Steinar på 4:e plats, Martin på 8:e och Håkan på 11:e plats. Grattis till er alla.

Hela resultatlistan hittar ni här.

http://www.sqlug.se/Forum/tabid/80/forumid/22/threadid/803/scope/posts/threadpage/4/language/sv-SE/Default.aspx

SQL Server performance with Dynamics Axapta

The last couple of years I have spent a lot of time of and on tuning SQL Server performance in combination with Dynamics Axapta. There are some good blogs on this topic out on the internet, such as this one http://blogs.msdn.com/b/axinthefield/archive/2010/11/04/sql-server-trace-flags-for-dynamics-ax.aspx and this one http://sqlcat.com/sqlcat/b/top10lists/archive/2010/05/20/top-tips-for-maximizing-the-performance-amp-scalability-of-dynamics-ax-2009-systems-on-sql-server-2008.aspx for example. In this short blog I will summarize a litte bit, and also add my own thoughts and findings on some subjects. Please remember to always test these suggestions first, and that the tips might pre-req good knowledge in SQL Server to make sense in some cases!

Trace Flags

You should consider using the following trace flags in SQL Server in conjunction with Axapta: 1117, 1118, 4136 and 845 (On SQL Standard edition)

Indexes

You will need more than the standard indexes. And thy must be created from within AX. However AX does not generally support all SQL Server index options. The trick then is to CREATE the index from AX, then ALTER it from SQL to suit your needs. Rebuild your indexes when needed. Ola Hallngrens scripts at http://ola.hallengren.com are a very good place to start

Statistics

Some tables might need their statistics to be updated several times a day. If you experience declining performance, worse the longer time runs from your UPDATE STATISTICS job, you might have this problem. In addition, some tables needs to have their statistics updated WITH SAMPLE 40 PERCENT or higher Leave AUTO CREATE STATS and AUTO UPDATE STATS on on your AX database

Query Plans

Beware of problems with OPTION (FAST 1) wich exists in several places. Use Plan Guides to control this from the SQL side if needed. But the best is if you can get the AX developers to fix it on the application side. Parametersniffing is a big issue, especially if you have several companies in the same database, with uneven amounts of data. Trace Flag 4136 can help.

Other

Set Max Degree Of Parallellism to 1 Configure Tempdb to use the same number of files as the number of cores in your SQL Server machine. Set the files to the same size, and settings Make sure you limit SQL Server memory usage, so that enough memory is left for Windows, Monitoring, Backups etc. If you run clustered SQL Server, consider using SQL Server 2012, and place Tempdb on local SSD disks, as AX tends to use Tempdb a lot Beware of blocking that can go on for a long time. You might need block monitoring. Orphaned sessions can happen, even if you kill a session in AX, it might not kill the corresponding SPID in SQL Server. Also see blocking above.

And of course, you can always contact us if you need further help!

PASS Summit 2012 - Pre-Conference Sessions

Som vi skrivit tidigare kommer PASS Summit även i år hållas i Seattle mellan 5-9 november. De två första dagarna, måndag och tisdag finns då möjlighet till att gå på heldagssessioner. Vilka sessioner som finns att välja de olika dagarna är nu tillgängligt.

Pre-Conference Sessions

Alla övriga sessioner hittar man här:

Conference Sessions

SQL server 2012 - different database collation

A common problem with SQL server consolidation is different default collations between databases and the server default collation. The problem occurs with tempdb that will get the server default collation and when you create a temporary table that you use to compare or join to another database table, you’ll get an exception. In SQL server 2012 you can create a partial contained database, and by using contained databases you’ll inherit the database default collation when creating the temporary table. This will solved the issue with the exception.

This new feature will save you money, as you can put databases with different collations on the same instance and reduce the number of instances needed. Try the following script:

USE MASTER;

CREATE DATABASE [Sommarkollo2012] CONTAINMENT = PARTIAL ON PRIMARY
( NAME = N'Sommarkollo2012', FILENAME = N'C:\Program Files\Microsoft SQL Server\MSSQL11.SQL2012\MSSQL\DATA\Sommarkollo2012.mdf' , SIZE = 5120KB , FILEGROWTH = 1024KB )
LOG ON
( NAME = N'Sommarkollo2012_log', FILENAME = N'C:\Program Files\Microsoft SQL Server\MSSQL11.SQL2012\MSSQL\DATA\Sommarkollo2012_log.ldf' , SIZE = 2048KB , FILEGROWTH = 10%)
COLLATE Finnish_Swedish_CS_AI
GO

SELECT
            serverCollation=SERVERPROPERTY('collation'),
            sommarKollorCollation = DATABASEPROPERTYEX('SommarKollo2012','collation'),
            tempdbCollation=DATABASEPROPERTYEX('tempdb','collation');

USE SommarKollo2012;
GO

CREATE TABLE CollationTest
(
I INT NOT NULL IDENTITY(1,1),
A VARCHAR(50) NOT NULL
);

CREATE TABLE #CollationTest
(
I INT NOT NULL IDENTITY(1,1),
A VARCHAR(50) NOT NULL
);

INSERT INTO CollationTest (A) VALUES('Håkan Winther');
INSERT INTO #CollationTest (A) VALUES('Håkan Winther');

SELECT A FROM CollationTest
INTERSECT
SELECT A FROM #CollationTest;

BEGIN TRY
DROP TABLE #CollationTest;
END TRY
BEGIN CATCH
END CATCH
GO

USE master;
GO

DROP DATABASE [Sommarkollo2012];
GO

If you change the containment to none, the exception will occur.

If you have any questions regarding SQL server 2012 and collations, feel free to call us and one of our SQL server experts will help you.

/Håkan Winther

Microsoft Sommarkollo 2012

Denna vecka är SQL Service på turne med Microsoft Sommarkollo, där vi pratar oss varma om SQL Server 2012!

Håkan håller en session om nyheterna på utvecklar och BI sidan, och Steinar pratar om nyheterna på DBA sidan, bland annat AlwaysOn Availability Groups. Du träffar oss 26/6 i Stockholm, 27/6 i Göteborg och 28/6 i Helsingborg, vi ses där!

Mer info om Sommarkollo finns på http://www.microsoft.com/sv-se/sommarkollo/

Behind the Scenes of Creating Optimized Productivity

I den elfe episoden av "The Fantastic 12 of SQL Server 2012" kan vi höra och se Tobias Thernström när han berättar om "SQL Generator" som är en nyhet i SQL Server 2012 och exempel på hur man kan ta nytta av den.

http://blogs.technet.com/b/dataplatforminsider/archive/2012/06/21/the-fantastic-12-of-2012-behind-the-scenes-of-creating-optimized-productivity.aspx

Alla avsnitt i "The Fantastic 12 of SQL Server 2012: Behind the Scenes" hittar man här.

Ny uppdatering för SQL Server 2012

Den andra uppdateringen av SQL Server 2012 är nu tillgänglig i och med att den att den kumulativa uppdateringen nr 2 har släppts med rätt många förbättringar. Det troliga är väl också att nya uppdateringar kommer komma ganska ofta nu som det också har gjort tidigare vid nya versioner.

Som vanligt gäller det att alltid testa innan man gör förändringar i produktionsmiljön, dock bör man alltid kontrollera de förbättringar som kommer och därefter avgöra om man skall uppdatera.

Cumulative update package 2 for SQL Server 2012

PASS Summit 2012

Helt traditionsenligt kommer PASS Summit även i år hållas i Seattle mellan 5-9 november. De två första dagarna, måndag och tisdag finns då möjlighet till att gå på heldagssessioner. För dessa kommer man kunna anmäla och boka in sig sista veckan i juni. Dock kan man redan nu se vilka sessioner som finns att välja bland. Det samma gäller faktiskt de övriga sessionerna där 138 redan finns tillgängliga och flera lär det bli.

Allt detta hittar man här :

Pre-Conference Sessions
Conference Sessions

Att tänka på är att anmälniongsavgifterna stiger efter 30/6.

SQL Server mystery: Hekaton tables and Hekaton Procedures

Have you ever heard of Hekaton Tables and Hekaton Procedures in SQL Server? Neither had I until recently. And it seems neither have Google. I happened to stumble upon the mention of these mysterious object, and tried to find out more, but had no luck. But I wanted to share what I have seen of is so far, and ask you, the readers of our blog, if you might have some light to shed on this? If so, please comment on this blogpost.

To find the mention of Hekaton on your own SQL Server instance, run the following code:

select * from syscomments where text like '%hekaton%'

That should generate an output that indicates that sp_updatestats, sp_createstats and sp_recompile contains the word Hekaton.

The relevant lines of code are as follows:

from "sp_helptext sp_createstats":

-- filter out local temp tables, Hekaton tables, and tables for which current user has no permissions

-- Note that OBJECTPROPERTY returns NULL on type="IT" tables, thus we only call it on type='U' tables

if (

(@@fetch_status <> -2) and

(substring(@tablename, 1, 1) <> '#') and -- temp tables

((@table_type<>'U') or (0 = OBJECTPROPERTY(@table_id, 'TableIsInMemory'))) and -- Hekaton table

from "sp_helptext sp_updatestats"

-- filter out local temp tables and Hekaton tables

-- Note that OBJECTPROPERTY returns NULL on type="IT" tables, thus we only call it on type='U' tables

if ((@@fetch_status <> -2) and

(substring(@table_name, 1, 1) <> '#') and -- temp tables

((@table_type<>'U') or (0 = OBJECTPROPERTY(@table_id, 'TableIsInMemory')))) -- Hekaton tables

from "sp_helptext sp_recompile"

-- Hekaton procedure cannot be recompiled

-- Make them go through schema version bumping branch, which will fail

ObjectProperty(@objid, 'ExecIsCompiledProc') = 0)

None of that really tells us exactly what Hekaton tables and Hekaton procedures are, but might give some clues. The undocumented OBJECTPROPERTY(@table_id, 'TableIsInMemory') call (another mystery...) seems to indicate that it could possibly be connected to memory, caching or even the old and removed feature of DBCC PINTABLE? That would be a real surprise in that case.

The comments tells us the following: Hekaton Procedures cannot be recompiled using sp_recompile Hekaton tables can not update or create stats using sp_updatestats and sp_createstats

I know that this is not much, but if you have more information about this little mystery, please comment it on this blogpost or mail me at firstname.lastname@sqlservice.se

SQL server 2012 certifiering

Nu har certifieringarna till SQL server 2012 kommit. Certifieringarna kan du göra hos bland annat AddSkills och Informator

Vill du lära dig mer om SQL server 2012 så kan du gå en 2 eller 3 dagars kurs hos Labcenter som hålls av våra SQL server konsulter.

SQL Server Indexing strategies part 2 - clustered index

Indexing strategy

There are some different types of indexes in SQL server:

- Clustered index
- Non clustered index

Covering
Filtered

- Indexed views
- Column Store (SQL server 2012)

The most important index is the clustered index and you should choose your clustered index carefully. If you make the wrong decision you may end up with some terrible performance and maintenance issues. What is a wrong decision and what’s a right decision? Well, there is no right answer, but you should not create the clustered index without a thought. By creating a primary key with the table designer in SQL server, you automatically create a clustered index.

Is the primary key the best clustered index? Well, it depends! It depends on the datatypes, number of columns and how it’s being used.

It’s a common practice to use a surrogate key that doesn’t have any relation to the data as the primary key, like an IDENTITY column. Is the surrogate key a good candidate? It’s only one column, ever increasing and use 4byte for integer or 8byte for bigint. I keep repeating, “It depends”

How often do you search a range on the surrogate key? Do you keep getting singleton lookups on the surrogate key because you search on other columns, like a date range?

You can look at how your indexes are used with the following code:

SELECT * FROM sys.dm_db_index_usage_stats

SELECT * FROM sys.dm_db_index_operational_stats(DB_ID(),null,null,null)

This will tell you how many user seeks, user scans, user lookups and user updates. If you have a lot of lookups and few seeks/scans on the clustered index and a lot seek/scans on another index that might be a more useful index.

The other candidate for clustered index might not be ever increasing, but does it have to be? Well no, but you may experience more fragmentation then with an identity column. BUT using the identity column might give you some other headaches like:

- The identity column has no “real” meaning and you probably have to create an alternate key to avoid duplicate records. That gives you two indexes just to keep database consistency.
- If you need to insert data into an identity column, you need to use “set identity insert on” and that gives you a table lock.
- Indexes on increasing columns might give you issues with statistics, which in turn can give you a plan that is terrible from a performance perspective.

The main reason to keep the index column as narrow as possible is because the index columns of the clustered index will be stored in the leaf pages of the non clustered index to create a pointer to the rest of the columns, which is stored in the leaf pages of the clustered index. If you use many and/or wide columns in the clustered index, you will increase the size of the non clustered indexes, the number of IO operations and memory usage.

As you can see, there is a lot to think of when you design your tables, and you should test the best design for your database.

If you want to know more about indexing strategies for SQL server, you are welcome back next week or contact any of our SQL server consultants.

Långsam procedur

Ibland kan man uppleva att en stored procedure går långsamt jämfört med om man kör samma fråga i SSMS Query Analyzer. En trolig orsak till detta är då att olika exekveringsplaner används. Dessutom kan man ibland upptäcka att samma procedur börjar gå långsamt efter ett tag att så stora skillnader som minuter mot sekunder uppstår.

Detta fenomen kan bero på sk ”Parameter Sniffing” som i korthet beror på att de parametrar som används första gången när sp’n körs och skapar exekveringsplanen inte är så bra representanter för datat.

Det kan man lösa på det några olika sätt:
- Ett enkelt sätt är skapa om proceduren, dock kommer man troligen få göra det ganska regelbundet.
- Ytterligare ett sätt är att lägga till ”WITH RECOMPILE” i början av sp'n för att på sätt tvinga fram en omkompilering varje gång sp'n används.
- Ett mera jobbigt sätt är att jobba med sk Query Hints för att på så sätt tvinga fram en viss exekveringsplan. Detta sätt rekommenderar vi inte utan i undantagsfall eftersom det kräver en stadig bevakning allteftersom datat i tabellerna ändras.
- Det bästa sättet till slut är att använda sk lokala variabler och helt enkelt tilldela inparametrarnas värde till dem istället och sedan använda dessa i frågan.

Det är relativt ovanligt att man behöver göra på något av dessa sätt, men ibland är det nödvändigt. Hör av er till någon av oss om ni har ytterligar frågor eller funderaringar runt detta område att optimera prestandan på databaser i SQL Server miljöer.

Nu finns en ny uppdatering för SQL Server 2008 SP3

En av de mindre uppdateringarna för SQL Server 2008 SP3 har nu släppts. Det är enbart 4 nya buggrättningar som nu blivit fixat. Hur som helst finns den nedan för nedladdning.

Som vanligt gäller det att alltid testa innan man gör förändringar i sin produktionsmiljö.

Cumulative update package 5 for SQL Server 2008 Service Pack 3

Backup & Restore info

SQL Server innehåller ju tonvis med metadata och bla finns det massor av användbar information om vilka backup/restore som skett på servern.

I msdb databasen finns ett antal tabeller som var för sig eller kombinerade kan leverera intressant information.

Dessa tabeller är:
- backupfile
- backupfilegroup
- backupmediafamily
- backupmediaset
- backupset
- restorefile
- restorefilegroup
- restorehistory

Tex kan man få reda på:
-När restorades min databas senast
-Vilken server kommer backupen ifrån
-vilken backupfil användes vid restore
-Backupstorlek, okomprimerad/komprimerad, komprimeringsgrad
-Vad hette databasen när backupen togs
-När kördes backupen

Och koden för det ser ut så här:

SELECT rh.destination_database_name as [Restored database],
  rh.restore_date as [Time of restore],
  bs.server_name as [Source server],
  bs.database_name as [Source database name],
  bmf.physical_device_name as [Backup file name],
  bs.backup_start_date as [Time of backup],
  bs.backup_size as [Backup size],
  bs.compressed_backup_size as [Compressed backup size]
FROM msdb..restorehistory rh
INNER JOIN msdb..backupset bs on bs.backup_set_id = rh.backup_set_id
INNER JOIN msdb..backupmediafamily bmf on bmf.media_set_id = bs.media_set_id

SQL Server indexerings strategier del 1 - Generella rekommendationer

När du designar en databas bör du ha prestanda i åtanke, och indexerings strategi är en av de viktigaste sakerna att tänka på. Om du skapar för få eller för många index lider du av dålig prestanda. Om du inte har index för att täcka dina frågor, har du långsamma frågor, och om du har för många, kommer dina INSERT, UPDATE och DELETE att vara långsamma. Du måste balansera detta och det finns alltid avvägningar och inga enkla svar som fungerar för alla, men det finns vissa riktlinjer du kan följa.

I denna serie av blogginlägg jag ska försöka ge dig några av dessa riktlinjer.

- Skapa inte för många eller för få.
- Varje tabell ska ha ett klustrade indexet! Slut på diskussionen! (kanske en del säger att de små tabellerna inte ska ha, men jag täcker det i en senare post)
- Välj det klustrade index klokt, låt inte SQL Server Management Studio att välja det åt dig (genom att skapa en primärnyckel i tabellen designern).
- Indexera kolumner som används i en foreign key relation
- Testa din workload med dina index
- Övervaka din prestanda för att hitta nya index
- Ta bort index som inte används
- Skapa inte dubbletter av index
- Kolumnordningen i index räknas, om första kolumnen i indexet inte används i en WHERE / join sats kommer det att sluta med en scan
- Använd rätt fillfactor för varje index, räkna inte med serverns standardinställningen för fillfactor
- Överväg partitionering för prestanda och underhåll
- Använd datakomprimering för datawarehouse / rapportering databaser.
- Bygg om index på en regelbunden basis
- Uppdatera indexstatistik

Kom tillbaka en annan dag för mer information om specifika rekommendationer

Om du har några frågor är du välkommen att kontakta någon av våra SQL Server konsulter och vi kommer att hjälpa dig.

BIDS Helper

För oss som jobbar med SQL Server Analysis Server kan man få en otrolig hjälp av BIDS Helper. Detta är ett gratisverktyg som integreras i Visual Studio som en add-in och t.ex. är det mycket lättare och bättre att skapa aggregeringar än i själva Visual Studio. Detta är inte något nytt verktyg utan har funnits rätt länge för Visual Studio (BIDS). Däremot är det rätt nytt att man nu också kan använda det för SQL Server 2012 och Tabular Mode (SSDT).

http://bidshelper.codeplex.com/

The SQL Server 2012 Core Factor Table

I am sure you have heard of the new SQL Server 2012 licensing model, out with CPU licensing and in with Core licensing. But did you know that all cores are not created equal? In fact that is why we need the Core Factor Table, to describe the relative cost of a core. The core table can be changed over time, so check back at this link to see if there are any chhanges recently: http://go.microsoft.com/fwlink/?LinkID=229882 The current table looks like this:

Processor Type Core Factor

- All processors not mentioned below 1
- AMD 31XX, 32XX, 41XX, 42XX, 61XX, 62XX Series Processors with 6 or more cores 0.75
- Single Core Processors 4
- Dual Core Processors 2

Interestingly, we see that running on a one or two core processor costs as much as running on a processor with 4 cores. And some specific AMD processors (with 6 or more cores) are cheaper per core than any other processors

Read more about buying SQL Server 2012 at http://www.microsoft.com/sqlserver/en/us/get-sql-server/how-to-buy.aspx or contact us, and we will help you!

Job failed - failed to notify via email - dbmail in SQL2005

If you have configured Database Mail correct in the Management Studio wizard in SQL Server 2005 (yes, some still use that old but stable chump), with a profile connecting to a user etc, and also have set up a job so that a notification should be sent to you, when the job fails. Then you think you are done? Nope. You're not done yet.

There are this (agent) service settings to be made as well.

I read this at the end of a errormessage when a job failed, when I didn't get an errormail of the fact:

..."NOTE: Failed to notify 'BI_Mailbox' via email."

Followed some google advices, and for example, simply restarting SQL Server Agent did not work for our server.

This did the trick though, not hard to do at all :) had just forgot/did not know I needed to enable mail session in the agent, and unfortunately that requires a restart of the agent service before it works. A task that sometimes needs lots of negotiations and getting approvals, which is not always easy in heavily used environments. You don't want to be forced to wait for a service window a week later for the for the restart so job mails start working. Many admins know what I'm talking about:

1. In Management Studio, right-click SQL Server Agent again and select "Properties."

2. Click "Alert System"

3. Click "Enable mail profile"

4. Click "OK"

5. Restart SQL Server Agent.

/Jonas Bergström

Guest Blog: Keeping track of SQL Server Agent job durations

About me My name is Mikael Cedersved, also (un)known as FrozenFishes. I’m a 26 year old DBA and BI developer from Sweden, working in the health care industry. I’ve been working with SQL server for 4 years. This is actually my first sql server related blog post, and I hope there’s several more to come. I’m about to launch my own blog at http://frozenfishes.wordpress.com, so stay tuned on that! You may also follow me on twitter @frozenfishes. First of all I want to thank Steinar Andersen and the people at SQL Service for letting me write a blog post here. And thanks again for putting Sweden on the SQL Server world map!

Recently I started thinking about how to monitor over all performance for our data warehouse and mostly the impacts of different changes to the environment as a whole and over time. Both inside SQL server, but also at HW/OS level. E.g if you're switching over to another SAN solution, making changes to the memory configuration or having table compression turned on. I figured one way to do this is to keep track of sql server agent job durations, since this is often not only used to execute all the SSIS packages for ETL, but also for a lot of cmdexec tasks doing various things in the environment such as processing a large number of files in some way etc. You'll then want to know how big the time saving (or loss) was in the big picture.

This could also be highly interesting numbers to look at if you're bound to specific maintenance time windows, when it's acceptable that your data is unavailable or inconsistent, and you're having trouble fitting everything in there. Then you want to know which job durations are stable and which are not, and which jobs take the longest time to finish when it matters, so that you can focus troubleshooting and performance optimization to these bad guys. Of course this is not very specific, and will barely provide any help at all when it comes to troubleshooting. It's also more of a measure for what's going on in means of modifications to these jobs, than performance in the environment, if your agent jobs changes often and a lot. In my own case we have quite stable jobs that, if changed it's not supposed to affect these durations very much. Although this might give you a hint of when a problem occurs and you need to look at the specifics. In a perfect world the only one making changes to these agent jobs would be the DBA, so that he/she always know what's going on in there. At least I would like it to be like this. Although I'm pretty certain this is not true in many cases.

This might raise an alert to you as a DBA, when a developer has made significant changes to a job - so that you'll get the opportunity to check it out and see how it copes with what you know is the fastest and best way of doing these things and make sure it doesn’t affect job durations to the point that it will interfere with other things such as backups or different maintenance tasks. There's some time calculation to be done here.

The following query will return one row per job, and information about the most recent run. If there's jobs that never has been run this will be returned with '1970-01-01' as RunDate. I use this query in a agent job to insert the results into a table, so that I can look at the results and variations over time with the help of a SSRS report. I scheduled this to run once a day.

SELECT CAST(convert(char(8), CASE a.last_run_date WHEN 0 THEN '19700101' ELSE a.last_run_date END) AS date) as RunDate, CASE LEN(a.last_run_time)

WHEN 5 THEN '0' + LEFT(convert(nvarchar(6),a.last_run_time), 1) + ':' + (SUBSTRING(convert(nvarchar(6), a.last_run_time), 2, 2)+ ':' + RIGHT(convert(nvarchar(6), a.last_run_time), 2))

WHEN 6 THEN LEFT(convert(nvarchar(6), a.last_run_time), 2) + ':' +(SUBSTRING(convert(nvarchar(6), a.last_run_time), 3, 2) + ':' +RIGHT(convert(nvarchar(6), a.last_run_time), 2))

ELSE '23:59:59' END AS RunTime, b.name as JobName,

(select COUNT(step_id) from [msdb].[dbo].[sysjobsteps] where job_id =a.job_id) as NbrOfSteps,

CASE a.last_run_outcome WHEN 0 THEN '#FAILED#'

WHEN 1 THEN 'Succeeded'WHEN 3 THEN '#STOPPED#' ELSE 'N/A' END AS Outcome,

CASE LEN(a.last_run_duration)

WHEN 1 THEN a.last_run_duration

WHEN 2 THEN a.last_run_duration

WHEN 3 THEN (convert(decimal, LEFT(a.last_run_duration, 1)) * 60) +RIGHT(a.last_run_duration, 2)

WHEN 4 THEN (convert(decimal, LEFT(a.last_run_duration, 2)) * 60) +RIGHT(a.last_run_duration, 2)

WHEN 5 THEN (convert(decimal, LEFT(a.last_run_duration, 1) * 60) * 60) +(convert(decimal, SUBSTRING(CAST(a.last_run_duration AS nvarchar(5)), 2, 2)) * 60) +RIGHT(a.last_run_duration, 2)

WHEN 6 THEN (convert(decimal, LEFT(a.last_run_duration, 2) * 60) * 60) +(convert(decimal, SUBSTRING(CAST(a.last_run_duration AS nvarchar(6)), 3, 2)) * 60) +RIGHT(a.last_run_duration, 2)

END AS DurationInSecs,

CASE LEN(a.last_run_duration)

WHEN 1 THEN cast(convert(decimal, a.last_run_duration) /60 AS decimal(6,2))

WHEN 2 THEN cast(convert(decimal, a.last_run_duration) /60 AS decimal(6,2))

WHEN 3 THEN cast(LEFT(a.last_run_duration, 1) + (convert(decimal,RIGHT(a.last_run_duration, 2)) /60) AS decimal(6,2))

WHEN 4 THEN cast(LEFT(a.last_run_duration, 2) + (convert(decimal,RIGHT(a.last_run_duration, 2)) /60) AS decimal(6,2))

WHEN 5 THEN cast((convert(decimal, (LEFT(a.last_run_duration, 1)) * 60) +SUBSTRING(CAST(a.last_run_duration AS nvarchar(5)), 2, 2) + (convert(decimal,RIGHT(a.last_run_duration, 2)) /60)) AS decimal(6,2))

WHEN 6 THEN cast((convert(decimal, (LEFT(a.last_run_duration, 2)) * 60) +SUBSTRING(CAST(a.last_run_duration as nvarchar(6)), 3, 2) + (convert(decimal,RIGHT(a.last_run_duration, 2)) /60)) AS decimal(6,2))

END AS DurationInMins,

CASE LEN(a.last_run_duration)

WHEN 1 THEN cast(convert(decimal, a.last_run_duration / 60) /60 AS decimal(6, 2))

WHEN 2 THEN cast(convert(decimal, a.last_run_duration / 60) /60 AS decimal(6, 2))

WHEN 3 THEN cast((convert(decimal, LEFT(a.last_run_duration, 1)) /60) +(convert(decimal, RIGHT(a.last_run_duration, 2)) / 60) /60 AS decimal(6,2))

WHEN 4 THEN cast((convert(decimal, LEFT(a.last_run_duration, 2)) /60) +(convert(decimal, RIGHT(a.last_run_duration, 2)) / 60) /60 AS decimal(6,2))

WHEN 5 THEN cast(LEFT(a.last_run_duration, 1) + (convert(decimal,SUBSTRING(CAST(a.last_run_duration AS nvarchar(5)), 2, 2)) /60) + (convert(decimal,(RIGHT(a.last_run_duration, 2)) / 60) /60) AS decimal(6,2))

WHEN 6 THEN cast(LEFT(a.last_run_duration, 2) + (convert(decimal,SUBSTRING(CAST(a.last_run_duration AS nvarchar(6)), 3, 2)) /60) + (convert(decimal,(RIGHT(a.last_run_duration, 2)) / 60) /60) AS decimal(6,2))

ELSE 0 END AS DurationInHrs

FROM [msdb].[dbo].[sysjobservers] a inner join [msdb].[dbo].[sysjobs] b on a.job_id = b.job_id order by a.last_run_date, a.last_run_time

WHERE

Ibland är WHERE inte alltid vad vi tänker på, nämligen i våra SQL-satser. Man kan ju också använda det för att söka efter filer. Det gör man i kommandofönstret och som standar sker sökningen då i den aktuella mappen och i de sökvägar som anges i mijövariabeln PATH. Ett exempel följer nedan då jag söker efter SQLDiag som jag kommer återkomma till i kommande inlägg.

Resulatet kommer sedan blixtsnabbt.

Which tables do I have SELECT permissions on?

I would like to share a little tip form Books Online, that I found the other day. Sometimes it is needed to find out what my permissions are. A good function to use in that case is HAS_PERMS_BY_NAME. If for example I would like to find out what tables I have SELECT permissions on, I could run the following query:

SELECT HAS_PERMS_BY_NAME (QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME(name), 'OBJECT', 'SELECT') AS have_select, * FROM sys.tables

Read more about HAS_PERMS_BY_NAME at http://msdn.microsoft.com/en-us/library/ms189802.aspx

Resource Governor Lite with QUERY_GOVERNOR_COST_LIMIT ?

Recently I had an idea about trying to emulate some of the functionality of Resource Governor using options available in Microsoft SQL Server Standard Edtion. The SET Option QUERY_GOVERNOR_COST_LIMIT is available in all versions of SQL Server, and promises to let us configure a maximum limit on the cost of a query that will be allowed to execute. This is what Books Online has to say about it:

"Use the query governor cost limit option to specify an upper limit on the time period in which a query can run. Queries that have estimated run times greater than this limit, return an error and are not executed. Query cost refers to the estimated elapsed time, in seconds, required to complete a query on a specific hardware configuration.

If you specify a nonzero, nonnegative value, the query governor disallows execution of any query that has an estimated cost exceeding that value. Specifying 0 (the default) for this option turns off the query governor, and all queries are allowed to run without any time limitation.

If you use sp_configure to change the value of query governor cost limit, the changed value is server wide. To change the value on a per-connection basis, use the SET QUERY_GOVERNOR_COST_LIMIT statement.

The query governor cost limit option is an advanced option. If you are using the sp_configure system stored procedure to change the setting, you can change query governor cost limit only when show advanced options is set to 1. The setting takes effect immediately (without a server restart)."

So, in other words we can set it on the server level but that affects all queries even the too costly ones that we would like to let run anyway, and the users themselves can change it on the session level.

Scenario: You have a SQL Server instance with a homegrown application. Users are not only connection via the application, but also via Excel, Access, Query Analyzer, PowerPivot or other similar uncontrolled ways. You would like to let the continue with that, but not in a way that kills the performance of the entire server, and all other users of your application.

The plan is as follows:

Configure QUERY_GOVERNOR_COST_LIMIT to 100 on the server level using the following code.

exec sp_configure 'show advanced options', 1

exec sp_configure 'query governor cost limit', 10 --(For our testing purposes only. In real life you would likely set it higher, for example 200)

go reconfigure

Then, since this is a homegrown application, you configure your application to remove the limit on its own sessions at logon time, using the following statement:

SET QUERY_GOVERNOR_COST_LIMIT 0

This would work well, atleast until your rouge users read this blog post :-)

To verify the functionality of this, log on to SQL Server and run the following query:

select * from master.sys.objects ma cross apply msdb.sys.objects ms

You should get the following error: Msg 8649, Level 17, State 1, Line 2 The query has been canceled because the estimated cost of this query (34) exceeds the configured threshold of 1. Contact the system administrator.

Now run our secret command to give you access to the unlimited power of SQL Server:

SET QUERY_GOVERNOR_COST_LIMIT 0

Run the query again: select * from master.sys.objects ma cross apply msdb.sys.objects ms

...and you should succeed!

Good luck!

Database Mirroring & CHECKDB

Att man skall köra CHECKDB på sina databaser regelbundet har väl de allra flesta koll på hoppas jag.
Datat man lagrar i databaserna kan vara mer eller mindre värdefullt, i vissa fall kan verksamheten vara direkt beroende av att datat är intakt och även tillgängligt dygnet runt utan avbrott.

För att uppnå en form av redundans kan man använda sig av Database Mirroring. Till skillnad från kluster där databasfilerna befinner sig på ett ställe rent fysiskt så har en Database Mirroring installation en primär databas och en spegel databas som helst befinner sig på en annan server och därmed även en annan disk.

I klusterfallet kan man köra CHECKDB på sin databas och därmed vara säker på att man gjort vad man kan för att upptäcka korruption.

I Database Mirroring fallet blir det lite mer komplicerat eftersom vi ju faktiskt har en sekundär server där databasen speglas. Antag att du regelbundet kört CHECKDB på den primära databasen och i och med det tror att allt är ok och sedan råkar ut för någon form av problem vilket orsakar en failover till spegeln. I det här läget skall man vara medveten om att man använder en databas som man aldrig kontrollerat. I värsta fall är en failover inte ens möjlig och det är väl inte riktigt vad man förväntar sig när man investerat i mer hårdvara, lagt ner tid på att sätta upp Mirroring mm...

Vad kan man då göra för att undvika detta?
Spegeldatabasen är ju i "restoring" läge och är i och med det inte online. Man kan dock skapa en shapshot av databasen och mot den kan man köra CHECKDB. Eftersom vi fortfarande inte kör på den faktiska databasen så kan vi ändå inte vara helt säkra men det är i alla fall bättre än att inte göra några kontroller alls på spegeln.
Ett database snapshot kan man ju även använda till annat än att köra CHECKDB mot, tex rapportering om man vill avlasta den primära databasen.

Enda sättet att vara helt säker är att periodvis växla till spegeldatabasen och där köra CHECKDB.

Tveka inte att kontakta oss om ni är det minsta osäkra på hur man säkrar upp SQL Server databaser på bästa sätt.

Is Dynamic T-SQL a Good Design Pattern?

In a recent discussion it was suggested to me that not only is dynamic T-SQL useful for things like catch-all queries or some really hard to solve problems involving variable table lists, but is, in fact, a perfectly acceptable design pattern for all queries against a database. Note, in this case, we’re not talking about an ORM tool which takes control of the system through parameterized queries, but rather an intentional choice to build nothing but dynamic T-SQL directly on the system.

To me, this was immediately problematic. I absolutely agree, you’re going to have dynamic T-SQL for some of those odd-ball catch-all search queries. But to simply expand that out to include all your queries is nuts. There really is a reason that stored procedures exist, and it’s not to build dynamic T-SQL. First things first, we are talking about using sp_executesql so we can avoid problems with SQL Injection, although that should be the very first concern that comes from this methodology. But after that, you need to worry about your management of the system. Here’s an example query:

CREATE PROCEDURE [dbo].[SearchRecords] @searchQuery AS NVARCHAR(100), @col AS VARCHAR(100) AS BEGIN

SET NOCOUNT ON; DECLARE @SQL NVARCHAR(1000); DECLARE @value NVARCHAR(100);

SET @value = @searchQuery;

IF (@col = 'PERSON_ID') BEGIN SET @SQL = 'SELECT * FROM dbo.Movie WHERE MovieId = @value'; END ELSE IF (@col = 'FIRST_NAME') BEGIN SET @SQL = 'SELECT * FROM dbo.Movie WHERE MovieName = @value';

END

EXEC sp_executesql @SQL,N'@value nvarchar(20)',@value=@value;

END

No chance of SQL injection with this, but there are other problems. The first one that comes up for me is that I’ve had to use a generic data type for @value, NVARCHAR(100). I’m passing that to both an ID and a NVARCHAR which means, when passing it to the ID I’m going to get a implicit conversion, possibly affecting index use for that part of the query. But it gets worse. Let’s execute the query twice, but I want clear the cache (please only do this on test systems):

DBCC FREEPROCCACHE();

EXEC dbo.SearchRecords @searchQuery = N'42', -- nvarchar(100) @col = 'PERSON_ID' -- varchar(100);

EXEC dbo.SearchRecords @searchQuery = N'Serpico', -- nvarchar(100) @col = 'FIRST_NAME' -- varchar(100);

So now we have two different plans in cache. If I query the cache like this:

SELECT deqp.query_plan, deqs.execution_count, deqs.query_hash, deqs.query_plan_hash, dest.text, OBJECT_NAME(dest.objectid)

FROM sys.dm_exec_query_stats AS deqs

CROSS APPLY sys.dm_exec_sql_text(deqs.sql_handle) AS dest

CROSS APPLY sys.dm_exec_query_plan(deqs.plan_handle) AS deqp;

I get a set of results that looks like this:

Note the lack of of an OBJECT_NAME. This is because there is no objectid stored with the plan created by sp_executesql. So, if I had hundreds of procedures that generated hundreds or even thousands of different queries through a dynamic process like this, I have absolutely no way of know which of the hundreds of procedures generated which query without going through and doing text searches against the code. I have to worry about SQL injection and I’m going to be doing all kinds of crazy searches to find the code that I need to tune or modify? No, for me, this is a very poor design pattern and not one I would suggest people adopt.

Veckans fråga med svar - vecka 18

En av nyheterna när det gäller SQL Server 2012 är möjlighet till 15 000 partitioner.

Veckans fråga v 18 till Håkan Winther handlar om just partitionering.

När skall man använda det och finns det någon bra tumregel för hur stora tabellerna skall vara ?
Vilka är fördelarna med partitionering och vilka eventuella nackdelar innebär det?

Svar:

Datakomprimering och partitionering är några av mina favorit features i SQL server som mycket väl kan motivera kostnaden för Enterprise edition fastän den är dyrare. I själva verket så kan man minska sina kostnader, öka tillgänglighet och prestanda med komprimering och partitionering.

När ska man använda partitionering? Som vanligt när det gäller SQL server så beror det på (”it depends”). Det finns dock flera scenarier där man ska överväga, testa och implementera partitionering:

- Laddning, arkivering eller borttagning av data skapar låsningar som påverkar andra processer, eller tar för lång tid
- Omindexering av en hel tabell tar för lång tid, påverkar för mycket eller service fönster saknas
- Man har frågor som enbart söker på delmängder (partitioner) av data
- Tabeller med columnstore index ska laddas med ny data
- Man vill spara på diskkostnad utan att förlora prestanda på den mest frekvent använda partitionen

Det finns dock inte några fördelar som inte har några nackdelar, framförallt så finns det en del begränsningar om man vill kunna nyttja ”fast partition switching” för att ladda eller arkivera data.

Några av fördelarna med partitionering är:

- Snabbare frågor som enbart hanterar ett fåtal paritioner
- Olika komprimeringsnivå kan ställas för olika partitioner
- En tabell kan spridas på flera filgrupper som kan placeras mot olika typer av disksystem
- Omindexering kan göras på enskilda partitioner, dock ej online
- Data kan flyttas blixtrande snabbt mellan tabller tack vare fast partition switching

Vid små tabeller så överväger nackdelarna men vid stor tabeller så överstiger normalt fördelarna, vilket gör att vinsten med partitionering på små tabeller inte är så stor. Finns det då någon bra tumregel som säger hur stor tabellen ska vara innan man utvärderar partitionering? Inte någon direkt officiell tumregel, men personligen så brukar jag överväga det vid tabeller på över 100GB eller om det finns problem som kan lösas av partitionering.

Det är relativt lätt att implementera partitioner, men det viktigaste att tänka på innan är att välja en bra partitioneringsnyckel

Du kan läsa mer om partitionering i kommande bloginlägg, men om du har några frågor som du vill ha svar på redan nu så är du varmt välkommen att kontakta mig eller några av våra SQL server konsulter.

/Håkan Winther

Slowly Changing Dimension - SSIS 2012

En klar förbättring bland många andra i nya SQL Server 2012 är faktiskt den så ofta hatade "Slowly Changing Dimension" i SSIS. Den har ju sina nackdelar när det gäller prestanda, men för mindre mängder är den ganska ok. Det som tidigare har varit rätt jobbigt är när man gjort en uppdatering mha den. Detta är nu löst på detta sätt som jag tycker är helt ok, än så länge i alla fall :-). Visst blir det lite handpåläggning men klart bättre än tidigare.

Före :

Efter ändringen:

TechDays 2012

SQL Service är som vanligt representerade på TechDays, både som talare och utställare. I år visar vi bland annat SQL Server 2012, SQL Azure och givetvis visar vi upp vår nya site som är byggt på SQL Azure och Windows Azure. Vi pratar även gärna om vårt kursutbud inom SQL Server, som vi genomför i samarbete med LabCenter.

Kom gärna förbi vår monter och hälsa på!

What is the difference between a predicate and a seek predicate?

If you look at the Index Seek operator in a query plan of a SQL Server SELECT query, you will sometimes see that you have both a Seek Predicate and also a Predicate.

So what is the difference between these two properties of the Index seek?

Seek Predicate is the seek operation that uses the b-tree part of the index to find matching rows.

Predicate is an operation that after the Seek Predicate operation does additional filterin using non-key columns (and sometimes also on indexed columns). If this is a non clustered index it seems unintuitive to me that we would not use only Seek Predicate (except on included columns) but I have seen i happen, and my theory so far is that it might be related to statistics.

In any case, you should expect much better performance from Seek Predicate operations only Index seeks compared to Index Seeks that include both Seek Predicate and Predicate properties.

Joke time!

People think that we who work with databases are boring people -I say NO, we´re not:
Proof (and one of my personal favorites!):

Q1: What did the DBA say to the Developer? A: It doesn’t matter, he wasn’t listening anyway.
Q2: What did the Developer say to the DBA? A: It doesn’t matter, the answer was no.

Under Creative Commons License: Attribution

Don´t forget to have fun out there, at least occasionally:)

Första uppdateringen av SQL Server 2012

Som förväntat kom den första s.k kumulativa uppdateringen av SQL Server 2012 ganska snabbt efter lanseringen. Man kan väl också anta att det varit låst för uppdateringar ganska länge för utvecklingsteamet. Hur som helst finns den nu här för nedladdning.

Som vanligt gäller det att alltid testa innan man gör förändringar i produktionsmiljön.

Move T-SQL templates

If you are a frequent user of templates in Management Studio you might have stumbled on the problem that when you change computer or reinstall your computer all your custom templates are gone. My first thought was that there must be an option to export the templates in Management Studio but there doesn't seem to be one. Ok, i guess they must be stored in the file system somewhere and if so, you can move your templates from one computer to another. Now we just have to find them... It seems the templates are stored locally in the profile and in my case i found them here: C:\Documents and Settings\JANNE\Application Data\Microsoft\Microsoft SQL Server\100\Tools\Shell\Templates\Sql

Where "JANNE" is a placeholder for whatever account name you might have. Now you just have to copy the parts you want and put them in the new location. There are a lot of pre-defined templates that you might not want to move but you can just copy the parts you want and that's all there is to it. Just remember to copy your custom templates before you reinstall. Same goes for your help favorites in Books Online. These can also be moved and i found them here: C:\Documents and Settings\Janne\Application Data\Microsoft\Microsoft SQL Server\100\Tools\Shell\vs help data The help favorites are located in a file called: Favorites.xml so all you have to do is move this file to the new location.

SQL server 2012 + SQL Azure = Sant

Passa på att träffa och lyssna på Håkan Winter i Örebro under TechDays den 26/4 och hör om SQL server 2012 + SQL Azure = Sant. Kom även och möt oss i vår monter. Ses där!

Träffa Alberto Ferrari!

Passa på att träffa och höra Alberto Ferrari som kommer vara i Stockholm den 24/5. Träffen sker på nästa möte i den svenska SQL Server användarföreningen. Anmälan kan göras här. Alberto Ferrari är en välkänd talare när det gäller SSAS och bl.a. medförfattare till boken "Expert Cube Development with Microsoft SQL Server 2008 Analysis Services" som jag kan varmt rekommendera med många tips & tricks, t.ex. när det gäller prestandaoptimeringar av kuber.

Veckans fråga med svar - vecka 14

Martin skrev i senaste "Veckans fråga" en hel del om exekveringsplaner. Av erfarenheter vet vi att dessa inte är helt lätta att läsa.

Veckans fråga vecka 14

Finns det något tips på hur man kan lära sig att läsa dem?

Svar : Jag brukar studera följande gratisbok: SQL Server Execution Plans av Grant Fritchey

Som finns tillgänglig här: http://downloads.sqlservercentral.com/Books/dissecting_complete.pdf?utm_source=ssc&utm_medium=weblink&utm_content=Grant&utm_campaign=sqltoolbelt

/Joakim Nyström

Lägre priser på SQL Azure!

Microsoft har justerat ned priserna på SQL Azure och även ändrat debiteringsmodellen något. Här nedan ser du de nya priserna i Svenska kronor. Som det framgår av tabellen kan det innebära upp till 95% lägre pris i vissa fall!

Databasstorlek	Pris Per Databas Per Månad	Besparing jämfört med tidigare pris
Databasstorlek	Pris Per Databas Per Månad	Web Edition	Business Edition
Upp till 100 MB	33,5290 kr	50%	95%
Mer än 100 MB upp till 1 GB	67,0579 kr	Samma pris	90%
Mer än 1 GB upp till 10 GB	67,0579 kr för första GB 26,8232 kr för varje extra GB	30% till 48%	54% till 86%
Mer än 10 GB upp till 50 GB	308,4667 kr för första GB 13,4116 kr för varje extra GB	N/A	75% till 76%
Mer än 50 GB upp till 150 GB	844,9307 kr för första GB 6,7058 kr för varje extra GB	N/A	55% till 75%

Optimize for Ad hoc

Ett problem som kan inträffa om man har många olika varianter av ad hoc frågor som aldrig upprepas är att plan cachen kan fyllas upp med en massa planer som aldrig kommer användas. För att undvika detta scenario finns kan man konfigurera SQL Server så att effekten av detta minimeras. Detta kan man dels göra i Management Studio under Server Properties/Advanced där man hittar flaggan "Optimize for Ad hoc Workloads" eller med sp_configure. Denna ser till så att första gången en plan sparas så sparas endast en liten del av planen och därmed utnyttjas cachen bättre. Skulle nu samma fråga komma en gång till så kommer SQL Server att spara en fullständig plan i cachen och frågan behandlas därefter som vanligt. Innan man ger sig på detta måste man ha koll på vad som finns i plan cachen. Detta kan man ta reda på genom att studera sys.dm_exec_cached_plans som visar hur fördelningen ser ut men vad vi egentligen är intresserade av är hur mycket av cachen som upptas av planer för ad hoc frågor som bara körts en gång.

Här kan man hitta ett skript som visar hur mycket utrymme som upptas av respektive objekttyp i cachen. Om du upptäcker att större delen av cachen upptas av planer för ad hoc frågor som bara körts en gång kan det vara läge att använda sig av "Optimize for Ad hoc Workloads".

Om du behöver hjälp med att avgöra vad som är bäst för just din miljö så hjälper våra SQL Server konsulter gärna till.

24 Hours of PASS: SQL Server 2012

Nu finns samtliga sessioner tillgängliga från 24 Hours of Pass som hölls för två veckor sedan under ett helt dygn. Detta kräver att man är registrerad användare hos PASS, men detta är helt gratis och något som jag hursomhelst rekommenderar. Tyvärr höll inte årets dragningar, upplägg och tekniska lösning samma höga kvalitet som tidigare år. Dock hittar man alltid något guldkorn och Grant Fritchley håller som vanligt hög klass. Allting hittar ni här.

Microsoft Business Intelligence Conference - Power to the User!

Förra veckan hölls den årliga BI-konferansdagen med Rafal Lukawiecki. Denna gång för Stockholm på Cirkus och en mycket bra dag där det mesta var riktigt bra. Lite förvånad var Rafal när så få av deltagarna hade använt Power Pivot som inte är en nyhet för SQL Server 2012, men däremot klart förbättrad med den nya versionen där man fått ihop helheten med SQL Servers nya version. Passa därför på att själv prova på nyheterna genom att boka upp er för våra kommande utbildningar som vi håller ihop med LabCenter där vi går igenom många av nyheterna och bjuder på rikligt med exempel. Nästa tillfälle går i Stockholm om två veckor och anmälan sker direkt i mail till patrik.sandqvist@labcenter.se.

Nya förbättringar av SQL Server 2008

För er som använder SQL Server 2008 är det värt att kontrollera de förbättringar som nu är tillgängliga i nya sk kumulativa uppdateringar. SQL Server 2008 SP2 Cumulative Update 9 SQL Server 2008 SP3 Cumulative Update 4 Som vanligt gäller det att alltid testa innan man gör förändringar i produktionsmiljön.

Server side trace

Tänkte ta tillfället i akt och slå ett slag för server side trace. Server side tracing har många fördelar framför att köra trace med Profiler.

Den främsta fördelen är att den är betydligt mindre resurskrävande. En server side trace har en nästintill obetydlig påverkan på serverns prestanda medan en trace med Profiler faktiskt har viss inverkan. Den som vill veta mer om detta kan läsa här: Personligen tycker jag att server side trace även är mycket mer flexibel. T. ex. kan man med hjälp av SQL Server Agent schemalägga en trace med start tid och skripta in stop tid.
En fördel om man inte vill sitta uppe kl 03.30 en lördagsnatt med profiler i högsta hugg för att starta en trace...

En annan sak som talar emot att köra trace med Profiler är det faktum att den temporärt lagrar resultatet under användarens profil vilket kan resultera i att man fyller upp diskutrymme snabbt om man har en hårt belastad server, något jag själv råkade ut för en gång för länge sedan innan jag visste bättre, och att fylla upp C: brukar sällan vara en god idé.

Om man, för att undvika ovanstånde, kör Profiler från en annan dator och inte direkt på servern skall man vara medveten om att man istället förbrukar bandbredd som står i direkt proportion till belastningen på servern. Nu vill jag inte påstå att man aldrig skall använda Profiler. Om man tex snabbt vill köra en trace för att studera något specifikt under en begränsad tid så är det troligtvis enklare att bara använda Profiler, göra det man skall och sedan stoppa tracen. Att skapa en server side trace är enkelt. Använd Profiler för att göra alla inställningar, skripta ut trace definitionen, editera lämpliga parametrar och starta sedan din trace i ett queryfönster eller schemalägg med SQL Server Agent. Oavsett vilket man väljer så skall man alltid se till att filtrera noga annars riskerar man att datamängden blir väldigt stor och med det även ens möjligheter att hitta det man söker.

How to redirect SSRS URL

When you install SQL Server Reporting Services version 2008 and 2008 R2, you do not need to install IIS. Even so the reports are web based, and accessed through a browser. This works because SSRS uses windows HTTP.SYS functionality to listen to http://servername:80/reports wich is your default reports URL. But what if you instead want to access your reports at http://servername ? Out of the box, you can't do that. So I wanted to share a little tips on how to accomplish that with minimum effort: 1. Install the "Web Server" Windows Server Role, and include the "HTTP Redirect" feature 2. Click on your server name and HTTP Redirect in IIS Manager (From Server Manager) and redirect from the default path to"/reports". Apply changes 3.

Done!

SQL Server 2012 - AlwaysOn #2

In previous blog post I wrote about one of the main benefits of AlwaysOn in SQL server 2012 and today I writing about another interesting benefit of AlwaysOn. Backups can actually be conducted on any of the replicas participating in the availability group, and you can even spread the log backups between multiple replicas! The log backups on the secondaries form a single log chain. If you experience performance issues in your primary database, you can move the workload of backups from your primary database to increase the performance. I haven’t tried it myself yet and I would have serious thoughts and serious testing before I would try it myself. If you spread the log backups to multiple secondaries you should store all the backups in a central location as you would need the complete log chain WHEN, not if, you need to restore the database. Backups is not something you would play around with, and you should make sure you have a well-documented and tested backup AND restore strategy. If you don’t have one, you can contact any of our SQL server experts and we will help you with that. Don’t wait with the backup/restore strategy to it`´s to late!

Veckans fråga med svar - vecka 12

Veckans fråga kommer ovan molnen på väg till vår nästa utbildning i Göteborg. Steinar skrev förra veckan att det blir viktigt att kunna klara sig på så få CORE som möjligt av kostnadsskäl med SQL Server 2012 pga den nya licensmodellen.

Fråga vecka 12

Vad kan vi som utvecklare göra för att klara oss med färre CORE ?

Svar: Hittills har vi som utvecklare kommit ganska lindrigt undan även om vi skulle slarva med att kontrollera hur våra frågor verkligen exekveras. Saknas det t. ex. ett index och SQL Servers optimerare väljer att göra en "table scan" så kan dessa ofta göras parallellt. Har vi då tillgång till många kärnor så går det ganska fort i alla fall. Nu är det slut med det. Självfallet skall vi även i fortsättningen utnyttja flera kärnor när vi behöver det - men det blir än viktigare att göra det i RÄTT frågor och inte slösa med det.

Orsaker till parallellism och hur vi hanterar den:

- Komplexa och/eller långa frågor
Vissa typer av frågor kräver hantering av stora datamängder, t.ex. rapporter med aggregerad information. Dessa har ofta mycket att vinna på att utnyttja flera kärnor och ska få göra det i fortsättningen också.

- Saknade/felaktiga index
Ett saknat index kan leda till onödig parallellisering av frågor som med rätt index skulle kunna exekvera snabbt även på en kärna.

- Ta för vana att inte bara kontrollera att du får rätt svar - utan kasta också ett öga på exekveringsplanen.
Titta efter de typiska blåa symbolerna, du ser dem snabbt.

- Konfiguration
SQL Server har huvudsakligen två inställningar som avgör om en viss fråga kommer att köras parallellt eller ej (förutsatt att det går!). Dessa inställningar ligger ibland utanför utvecklarens kontroll, men det är viktigt att känna till hur de fungerar. (Och många utvecklare dubblerar ju som DBA också!) Du kan enkelt kontrollera vilka inställningar du har med denna fråga: SELECT name, value_in_use FROM sys.configurations c WHERE c.name LIKE '%max degree%' OR c.name LIKE '%cost threshold%'

- Max degree of parallelism (MAXDOP)
Anger hur många kärnor varje steg i exekveringsplanen maximalt kan utnyttja och kan ställas in mellan 0 och max antal kärnor på servern. (0=parallellisera maximalt, 1="avstängd" parallellisering). Vilket värde som är optimalt beror bland annat på antalet tillgängliga kärnor, vilket typ av frågor som ställs (komplexa eller enkla) mm, men det får vi återkomma till.

- Cost threshold for parallelism
För varje exekveringsplan som SQL Server tar fram beräknas en total "kostnad" för exekveringen ("Estimated subtree cost" i bilden nedan). Om den kostnaden för den sekvensiella planen är högre än "cost threshold" så försöker SQL Server hitta en billigare parallell plan istället. Denna inställning har haft defaultvärdet 5 ända sedan SQL 2000 (och har det fortfarande i SQL 2012!), vilket är alldeles för lågt i de flesta sammanhang. En fråga med så låg kostnad vinner oftast inte mycket på att parallelliseras. Vad är då "rätt" inställning? Som vanligt; det beror på. Ett sätt att hitta en hyfsad nivå är att titta på de planer som SQL Server har sparat i cachen. Där plockar vi fram alla frågor som körs parallellt och går igenom de med lägst kostnad. Dessa testkör vi både parallellt och sekventiellt (använd query hint OPTION (MAXDOP 1)) och jämför exekveringstiderna. Är den inte avsevärt längre så kan vi höja cost threshold till strax över den (sekventiella) kostnaden.

Var ska jag börja då?
Titta på de aktuella frågorna i cachen med hjälp av denna fråga. Sedan är det bara till att beta av dem en efter en. OBS! På större system kan den ta lång tid att köra och det är bäst att köra den när det inte är så hög belastning!

WITH XMLNAMESPACES (DEFAULT 'http://schemas.microsoft.com/sqlserver/2004/07/showplan')

SELECT  n.value('(@StatementSubTreeCost)[1]', 'VARCHAR(128)') AS Cost  
 , n.query('.').exist('//RelOp[@PhysicalOp="Parallelism"]') AS IsParallel  
 , cp.objtype  
 , cp.usecounts  
 , cp.size_in_bytes  
 , st.text AS SQLStatement  
 , query_plan 
FROM sys.dm_exec_cached_plans AS cp 
CROSS APPLY sys.dm_exec_query_plan(plan_handle) AS eqp 
CROSS APPLY sys.dm_exec_sql_text(plan_handle) AS st 
CROSS APPLY query_plan.nodes('/ShowPlanXML/BatchSequence/Batch/Statements/StmtSimple') AS qn(n) 
WHERE  n.query('.').exist('//RelOp[@PhysicalOp="Parallelism"]')  = 1 
ORDER BY IsParallel DESC, Cost

/Martin Höglund

The eternal search for missing indexes, part 3

Hi again and thank you for all replies!
Now that you aquainted yourself with the missing index dmv:s, it is time to set the tools into proper work!

The best use of the dmv:s is actually to get a quick notice about which table is having the most problem trying to stay up to date. The top table in the dmv list is having issues. Key key for you as dba is to find out WHAT exactly the problem IS...

I normally start by setting ut a (server) trace of table access (as I normally am not involved in the software development process, for some strange reason; google: "developer dba conflict"). By analyzign the trace I will get two major results:

1. The highest average CPU process
2. The most frequent process.

The highest CPU is normally located to a poorly designed stored procedure, which is a fun problem for a DBD to chew on, the second problem is something you will have to contact the dev. team to have corrected (Q: Why the "&# are you asking "SELECT * FROM table" 60 times per minute in your application, ever heard of caching?). Finally, you will NOT use the dmv:s to create your new indexes, but instead via the steps above find the slow parts of the stored procedure and feed these parts into the Database Enging Tuning Advisor, which is a MUCH more qualified tool than the dmv:s. Don't forget, however, that the dmv:s will always tell you WHERE the problem lies, which the DETA will not.

Happy hunting!

SQL Server virtual labs

Have you ever wanted to just quickly have a look at a specific feature of SQL Server, without having to install the whole product on your computer? That is exacly what SQL Server Virtual Labs are for! Just klick in on http://www.microsoft.com/sqlserver/en/us/learning-center/virtual-labs.aspx and choose a lab, you will be up and running in minutes! At the moment there are 16 SQL Server labs available, covering SQL 2012 and SQL 2008 R2. If you want to do real life labs, SQL Service and LabCenter is giving SQL Server 2012 related labs in, more information about that is here, here and here.

24 Hours of PASS: SQL Server 2012

På onsdag är det dags för 24 Hours of PASS: SQL Server 2012. Under ett helt dygn hålls 24 stycken sessioner om SQL Server. Självklart handlar mycket om SQL Server 2012 och man får också ett smakprov av vad som skall komma i Seattle i november. Alltså väl värt tid för att lära sig mer om SQL Server.

SQL Server 2012 - alwayson #1

In the newly released SQL server 2012 you get some nice features and one of the best is AlwaysOn. You can use AlwaysOn to create a high availability & disaster recovery solution without the shared storage requirement as you have in a normal clustered environment. A side effect of this is that you can place your tempdb on local storage with some super fast SSD drives. That will increase the performance of queries that depend heavily on tempdb usage. Tempdb is used for temporary storage for sorting, grouping, hash matching, row versioning and temporary object. Using SSD drives in your SAN is may be very expensive, depending on how many SSD drives you need, but as SSD drives give you a lot more IOPS, you don't need as many as you would with FibreChannel disks and a couple of local SSD drives for your tempdb files may give you a real heavy performance boost. If you want to know more about SQL server 2012 you may contact any of our SQL server experts and we will help you.

You can also sign up for our 2 day course held at LabCenter

Guest Blog: Keeping track of SQL Server Agent job durations

You may also follow me on twitter @frozenfishes. First of all I want to thank Steinar Andersen and the people at SQL Service for letting me write a blog post here. And thanks again for putting Sweden on the SQL Server world map! Recently I started thinking about how to monitor over all performance for our data warehouse and mostly the impacts of different changes to the environment as a whole and over time. Both inside SQL server, but also at HW/OS level. E.g if you're switching over to another SAN solution, making changes to the memory configuration or having table compression turned on. I figured one way to do this is to keep track of sql server agent job durations, since this is often not only used to execute all the SSIS packages for ETL, but also for a lot of cmdexec tasks doing various things in the environment such as processing a large number of files in some way etc. You'll then want to know how big the time saving (or loss) was in the big picture.

At least I would like it to be like this. Although I'm pretty certain this is not true in many cases. This might raise an alert to you as a DBA, when a developer has made significant changes to a job - so that you'll get the opportunity to check it out and see how it copes with what you know is the fastest and best way of doing these things and make sure it doesn’t affect job durations to the point that it will interfere with other things such as backups or different maintenance tasks. There's some time calculation to be done here. The following query will return one row per job, and information about the most recent run. If there's jobs that never has been run this will be returned with '1970-01-01' as RunDate. I use this query in a agent job to insert the results into a table, so that I can look at the results and variations over time with the help of a SSRS report. I scheduled this to run once a day.

SELECT CAST(convert(char(8), CASE a.last_run_date WHEN 0 THEN '19700101' ELSE a.last_run_date END) AS date) as RunDate, CASE LEN(a.last_run_time) WHEN 5 THEN '0' + LEFT(convert(nvarchar(6),a.last_run_time), 1) + ':' + (SUBSTRING(convert(nvarchar(6), a.last_run_time), 2, 2)+ ':' + RIGHT(convert(nvarchar(6), a.last_run_time), 2)) WHEN 6 THEN LEFT(convert(nvarchar(6), a.last_run_time), 2) + ':' +(SUBSTRING(convert(nvarchar(6), a.last_run_time), 3, 2) + ':' +RIGHT(convert(nvarchar(6), a.last_run_time), 2)) ELSE '23:59:59' END AS RunTime, b.name as JobName, (select COUNT(step_id) from [msdb].[dbo].[sysjobsteps] where job_id =a.job_id) as NbrOfSteps, CASE a.last_run_outcome WHEN 0 THEN '#FAILED#' WHEN 1 THEN 'Succeeded'WHEN 3 THEN '#STOPPED#' ELSE 'N/A' END AS Outcome, CASE LEN(a.last_run_duration) WHEN 1 THEN a.last_run_duration WHEN 2 THEN a.last_run_duration WHEN 3 THEN (convert(decimal, LEFT(a.last_run_duration, 1)) * 60) +RIGHT(a.last_run_duration, 2) WHEN 4 THEN (convert(decimal, LEFT(a.last_run_duration, 2)) * 60) +RIGHT(a.last_run_duration, 2) WHEN 5 THEN (convert(decimal, LEFT(a.last_run_duration, 1) * 60) * 60) +(convert(decimal, SUBSTRING(CAST(a.last_run_duration AS nvarchar(5)), 2, 2)) * 60) +RIGHT(a.last_run_duration, 2) WHEN 6 THEN (convert(decimal, LEFT(a.last_run_duration, 2) * 60) * 60) +(convert(decimal, SUBSTRING(CAST(a.last_run_duration AS nvarchar(6)), 3, 2)) * 60) +RIGHT(a.last_run_duration, 2) END AS DurationInSecs, CASE LEN(a.last_run_duration) WHEN 1 THEN cast(convert(decimal, a.last_run_duration) /60 AS decimal(6,2)) WHEN 2 THEN cast(convert(decimal, a.last_run_duration) /60 AS decimal(6,2)) WHEN 3 THEN cast(LEFT(a.last_run_duration, 1) + (convert(decimal,RIGHT(a.last_run_duration, 2)) /60) AS decimal(6,2)) WHEN 4 THEN cast(LEFT(a.last_run_duration, 2) + (convert(decimal,RIGHT(a.last_run_duration, 2)) /60) AS decimal(6,2)) WHEN 5 THEN cast((convert(decimal, (LEFT(a.last_run_duration, 1)) * 60) +SUBSTRING(CAST(a.last_run_duration AS nvarchar(5)), 2, 2) + (convert(decimal,RIGHT(a.last_run_duration, 2)) /60)) AS decimal(6,2)) WHEN 6 THEN cast((convert(decimal, (LEFT(a.last_run_duration, 2)) * 60) +SUBSTRING(CAST(a.last_run_duration as nvarchar(6)), 3, 2) + (convert(decimal,RIGHT(a.last_run_duration, 2)) /60)) AS decimal(6,2)) END AS DurationInMins, CASE LEN(a.last_run_duration) WHEN 1 THEN cast(convert(decimal, a.last_run_duration / 60) /60 AS decimal(6, 2)) WHEN 2 THEN cast(convert(decimal, a.last_run_duration / 60) /60 AS decimal(6, 2)) WHEN 3 THEN cast((convert(decimal, LEFT(a.last_run_duration, 1)) /60) +(convert(decimal, RIGHT(a.last_run_duration, 2)) / 60) /60 AS decimal(6,2)) WHEN 4 THEN cast((convert(decimal, LEFT(a.last_run_duration, 2)) /60) +(convert(decimal, RIGHT(a.last_run_duration, 2)) / 60) /60 AS decimal(6,2)) WHEN 5 THEN cast(LEFT(a.last_run_duration, 1) + (convert(decimal,SUBSTRING(CAST(a.last_run_duration AS nvarchar(5)), 2, 2)) /60) + (convert(decimal,(RIGHT(a.last_run_duration, 2)) / 60) /60) AS decimal(6,2)) WHEN 6 THEN cast(LEFT(a.last_run_duration, 2) + (convert(decimal,SUBSTRING(CAST(a.last_run_duration AS nvarchar(6)), 3, 2)) /60) + (convert(decimal,(RIGHT(a.last_run_duration, 2)) / 60) /60) AS decimal(6,2)) ELSE 0 END AS DurationInHrs FROM [msdb].[dbo].[sysjobservers] a inner join [msdb].[dbo].[sysjobs] b on a.job_id = b.job_id order by a.last_run_date, a.last_run_time

IDENTITY function

As we all know we can create a table with an identity column, add rows and automatically get every row numbered sequentially. This requires that we first create a table with a column that has an identity property set. If you want to have a new table with a column that gives every row an increasing (or decreasing) number you don't have to make the extra move to first create the table with an identity column and then insert the data. Instead you can use the IDENTITY function. I recently found myself in a situation where i had to migrate some data and needed to assign every row a unique number. One alternative would have been to create a cursor, loop through all the records and have a variable that would increase it's value by 1 for every record and then insert the row. Not a very appealing solution. Instead i decided to select the data with an added identity column into a new table (which was the desired result by the way).

Here's an example: SELECT IDENTITY(INT, 1,1) AS ID, COL1, COL2....INTO NewTable FROM SomeTable This statement will create a new table, called NewTable, with a column called ID with datatype INT and the rest of the columns that are listed in the select statement. Note that the new column, ID, is created as an integer and does not have the IDENTITY property set so it does not behave like a IDENTITY after table creation. One restriction to this is that you can only use the IDENTITY function in a SELECT INTO statement. Why?? It would have been nice if you could use it with a plain regular insert...

SQL server 2012 - PARSE() & TRY_PARSE()

In SQL Server 2012 you have a lot new features to use and some of the improvements are in T-SQL. If you ever tried to convert a string value into a date or numeric datatype, you probably have been facing incompatible string values that are not possible to convert without some easy or complex string manipulations. I guess you have been facing issues like this: SELECT CONVERT(datetime,'Monday, 13 December 2010') AS Result SELECT CAST('måndag 13 december 2010 kl 10:12' AS datetime2) AS Result SELECT CONVERT(money,'3 455,98') AS Result SELECT CONVERT(datetime2, '12/16/2010') All of these statements will fail and you have to manipulate the strings to be able to convert them. Sometimes these issues will arise in implicit conversions when you try to insert string values into date or numeric columns and you need to find the record that is causing the problem. These issues can be solved by two of the new functions in SQL server 2012, PARSE() & TRY_PARSE().

With these functions you can use a language culture to handle different string formats. SELECT PARSE('Monday, 13 December 2010' AS datetime2 using 'en-US') AS Result SELECT PARSE('Måndag 13 December 2010' AS datetime2 using 'sv-SE') AS Result SELECT PARSE('Måndag den 13 December 2010' AS datetime2 using 'sv-SE') AS Result SELECT PARSE('måndag 13 december 2010 kl 10:12' AS datetime2 using 'sv-SE') AS Result SELECT PARSE('måndag 13 december 2010 klockan 10:12' AS datetime2 using 'sv-SE') AS Result --- Error! All of the selects above will return a valid datetime2 except the last on results in an error. To avoid the error you can replace the PARSE function with TRY_PARSE that will give you a NULL value instead of an error.

SELECT PARSE('€345,98' AS money using 'de-DE') AS Result SELECT PARSE('£345,98' AS money using 'de-DE') AS Result --- Error! SELECT TRY_PARSE('£345,98' AS money using 'de-DE') AS Result SELECT TRY_PARSE('€345,98' AS money using 'de-DE') AS Result In the example above you'll get an error on the second statement, becuase the £ sign is not a valid currency prefix for German language culture. The most interesting result you'll get for the following code: SELECT PARSE('1 53' AS DECIMAL(10,2)) AS Result SELECT PARSE('1,53' AS DECIMAL(10,2)) AS Result SELECT TRY_PARSE('1,53' AS DECIMAL(10,2) USING 'sv-SE') AS Result SELECT PARSE('1 53' AS DECIMAL(10,2) USING 'sv-SE') AS

Result As you can see in the result is that the Thousand sign for the specified language culture is just removed, causing 1,53 and 1 53 to become 153, instead of causing an exception. The thousand sign doesn't seem to have a meaning in PARSE, and this might cause you some sleepless nights if you thought you would get a different result.

If you have any questions regarding SQL server, feel free to contact us and our SQL server experts will help you.

The eternal search for missing indexes, part 2

Now that you have tried the script I presented last wednesday on your production server(s) I would like to fill you in on how I use it: The first column in the result set, improvement_measure, shows a weighted measure of several of the other columns in the result set. I usually do not concern myself about values below 1000 for this column. Secondly it is important to group the result into relevant tables. My procedure is to add a filter to the top 1 table in the result set as follows: AND mid.statement LIKE '%tablename%'

The result set with this extra WHERE clause will normally contain many similar rows with almost identical CREATE statements in the create_index_statement column. Now you should look at the differences between the statements and find a statement that covers all other statements (normally the most difference is in the INCLUDE part. Now, if your fellow programmer has done som bad programming here, AND you have a many column table, you will find INCLUDE statements that look ridiculous (= every column in the table included). Primary solution is to contact your fellow programmer and in a nice way explain that he (or she) cannot possibly be needing EVERY SINGLE column in the table!

The secondary solution is to make a loud heavy sigh, accept the fact, and try to exclude irrelevant columns yourself. Once you have executed the CREATE INDEX for the chosen index configuration, the DMVs will be reset for the table involved. Therefore you will have to patiently wait until the statistics build up again before you add new indexes to the table. Now you can reiterate the procedure above until you are below your chosen threshold value for the improvement_measure. to be continued...

Veckans fråga med svar - vecka 11

Nu introducerar vi veckans fråga till någon av våra konsulter. Frågan kommer på måndagar och svaret senere under veckan.

Fråga vecka 11

Ofta kan man se att SQL Server går på olika processorer, t.ex. E5540, X5650, L5640. Vad är dessa förkortningar och spelar det någon roll för SQL Server och vad är i så fall rekommendationen ?

Svar: Tack Göran för en fråga som nästan är omöjlig att svara på, på ett begripligt sätt :-) Dessa förkortningar är namnen på olika Intel server processorer (Det vill säga inte processorer till din laptop eller stationära dator). I detta svar kommer jag därför att fokusera på Intels processorer, men vi skall inte glömma bort att det även finns AMD. Att beskriva alla i detalj är en omöjlighet, det är helt enkelt för mycket information.

Då hänvisar jag till:
www.intel.com ,
http://www.intel.com/content/www/us/en/processors/processor-numbers.html
http://en.wikipedia.org/wiki/Xeon

Däremot kan en övergripande beskrivning nog vara till nytta, och det kommer jag att försöka mig på här. Intels olika processorer kan delas upp i ett antal familjer, som kort kan beskrivas så här: E3: För servrar med 1 CPU, med 2-4 cores per CPU (Ersätter gamla 3000 serien). Billigast E5: För servrar med upp till 2 CPU’er, med 4-8 cores per CPU (Ersätter gamla 5000 serien) Bäst pris/prestanda E7: För servrar med 2-256 CPU’er, med 6-10 cores per CPU (Ersätter gamla 7000 serien) Dyrast Vad då med bokstäverna X, E och L som brukar ligga med först eller sist i CPU namnen från Intel? L: Low Voltage, är som namnet antyder en variant med lägre strömförbrukning. Detta har givetvis inverkan på prestanda, så om prestanda är viktigt skall du undvika dessa processorer E: Mainstream, eller mellanklass. Fokus på pris/prestanda förhållandet. X: Performance. Kostar det så smakar det :-)

Det viktigaste att ta i beaktande framöver när du skall välja CPU till din SQL Server server, kommer oftast att vara price/performance eftersom SQL Server 2012 innebär ett byte av licensieringsmodell från per CPU till per CORE. I alla fall om du skall köra Enterprise Edition, som nu bara kommer att säljas per CORE, och inte längre finns tillgänglig under licensmodellen Server/CAL. Tidigare var det vid CPU licensiering lönsamt att köra CPU’er med så många CORE’s som möjligt, vilket gjorde att vi ofta rekommenderade AMD 12 CORE processorer. Nu kommer det bli precis tvärt emot, dvs att nu blir det viktigt att kunna klara sig på så får CORE som möjligt av kostnadsskäl. Då kommer vi antagligen oftare att rekommendera Intel 4 CORE CPU’er med så mycket kraft som möjligt i varje CORE.
/Steinar Andersen

SQL Server version 11.0.2100.60

Som ni säkert känner till, har SQL Server 2012 lanserats. Faktum är att lanseringen fortfarande pågår, det är inte för sent att logga in på www.sqlserverlaunch.com och ta del av mängder av sessioner om alla nya spännande nyheter! I rubriken har jag dock inte skrivit version 2012 utan version 11.0.2100.60. Detta är altså build numret för RTM (Release To Manufacturing) versionen av SQL 2012. Så om din installation har ett lägre nummer är det antagligen CTP1, CTP3 eller RC0 av SQL 2012. För att kolla vilken version av SQL Server du kör kan du antigen högerklicka på servernamnet i SQL Server Management Studio och välja properties. Eller så kan du köra följande lilla kodsnutt: SELECT SERVERPROPERTY('ProductVersion')

Vi har redan många kunder som håller på att komma igång med SQL 2012, eller planerar att göra det snart. Om ni vill att vi skall hjälpa er med att utnyttja möjligheterna i den nya SQL Server versionen, eller bara komma och berätta vilka möjligheterna är, kontakta oss så kommer någon av våra erfarna SQL Server konsulter ut till er. Som Microsoft Gold Data Platform Partner är vi rätt partner för er när det gäller SQL Server!

SQL Server 2012 Business Intelligence/Developer Skills Upgrade

SQL Service håller tillsammans med LabCenter en 2 dagarslabb i Stockholm och Göteborg. I denna tvådagarslabb framtagen av Håkan Winther COO på SQL Service och Göran Rönnbäck, konsult på SQL Service, lär du dig de relevanta nyheterna i Microsoft SQL Server 2012 för dig som idag är utvecklare eller BI utvecklare på tidigare versioner av SQL Server. Vi går igenom relevanta nyheter och tittar på hur de kan användas i verkligheten för att uppnå högre prestanda och bättre funktionalitet! Dag 1: -Översikt över nyheterna i SQL 2012 -Editions, features och licensiering i SQL 2012 -Installation av SQL Server 2012 -T-SQL nyheter Dag2: - Columnstore Index - Online operations - Full Text Search och Semantic Search - Nyheter i SSAS, SSIS och SSRS - Powerview och PowerPivot

Datum Göteborg: 21-22 mars Stockholm 19-20 april Längd: 2 dagar Pris per plats: 6.500 sek exkl moms

Anmälan sker direkt Patrik på LabCenter till mail: Patrik.sandqvist@labcenter.se

Behöver då informationen:
1.Val av datum
2. deltagarnamn
3. Email
4.full fakturadress.

Backup till NUL device

Att göra prestandamätningar kan ibland vara en tidskrävande process. Ofta behöver man titta på ett system en längre tid för att få en rättvis bild av mätdatat. En väldigt viktig parameter för hur bra SQL Server presterar är skrivhastigheten i disksystemet. Ett litet knep man kan använda för att snabbt bilda sig en uppfattning om hur skrivhastigheten på disk, eller hur lång tid en backup tar, är att ta en backup och skicka filen till ett sk NUL device. Observera att det är NUL med ett L inget annat. NUL kan väl närmast betraktas som en fil som tar bort allt som skrivs till den men ändå rapporterar att allt är normalt. Att ta backup brukar kunna ge en indikation av hur snabbt disksystem man har i bakgrunden. För att få lite mer matnyttig information kan skall man dock inte göra backupen med Management Studio utan via TSQL då man får mer detaljerad information om hur mycket som skrivits och hastigheten.

EX: Processed 6540000 pages for database 'XXXXX', file 'XXXXX_Data' on file 1. Processed 1 pages for database 'XXXXX', file 'XXXXX_Log' on file 1. BACKUP DATABASE successfully processed 6540001 pages in 420.212 seconds (121.590 MB/sec) Se bara till att göra backupen med COPY_ONLY option så du inte bryter backupkedjan. Ex: BACKUP DATABASE [Databasnamn] TO DISK = 'NUL' WITH COPY_ONLY;

The eternal search for missing indexes, part 1

Hi eveyone! I will begin my participation in this column by honoring Bart Duncan for a script utilizing dynamic management views (also known as DMV:s for short). The script simply lists up to 500 CREATE INDEX statements from three joined DMV:s. For the DBA user it is as simple as: cut - paste - execute. Here is the script:

SELECT

migs.avg_total_user_cost * (migs.avg_user_impact / 100.0) * (migs.user_seeks + migs.user_scans) AS improvement_measure

, 'CREATE INDEX [missing_index_' + CONVERT (varchar, mig.index_group_handle) + '_' + CONVERT (varchar, mid.index_handle)

+ '_' + LEFT (PARSENAME(mid.statement, 1), 32) + ']' + ' ON ' + mid.statement+ ' (' + ISNULL (mid.equality_columns,'')

+ CASE WHEN mid.equality_columns IS NOT NULL AND mid.inequality_columns IS NOT NULL THEN ',' ELSE '' END

+ ISNULL (mid.inequality_columns,'') + ')' + ISNULL (' INCLUDE ('+ mid.included_columns +')','') AS create_index_statement

, migs.*

, mid.database_id

, mid.[object_id]

FROM sys.dm_db_missing_index_groups mig

INNER JOIN sys.dm_db_missing_index_group_stats migs ON migs.group_handle = mig.index_group_handle

INNER JOIN sys.dm_db_missing_index_details mid ON mig.index_handle = mid.index_handle

WHERE migs.avg_total_user_cost * (migs.avg_user_impact / 100.0)* (migs.user_seeks + migs.user_scans) > 10

ORDER BY migs.avg_total_user_cost * migs.avg_user_impact * (migs.user_seeks + migs.user_scans) DESC

Bart Duncan´s original post can be found here: http://blogs.msdn.com/b/bartd/archive/2007/07/19/are-you-using-sql-s-missing-index-dmvs.aspx Now, test this at home and I will return next week with my usage recommendations :)

Microsoft Releases SQL Server 2012

Alldeles nyligt meddelar Microsoft att SQL Server 2012 RTM nu släpps. SQL Server 2012 RTM alltså och det finns redan nu möjlighet att ladda ned Microsoft® SQL Server 2012 Evaluation innan den 1 april :-) Då det stora släppet inleds. Noterbart är att den innehåller Performance Dashboard för SQL Server 2012. Glöm inte heller bort den virtuella lanseringen nu på onsdag 7/3 kväll med 20-minuters sessioner mellan kl 17-23. Go Further. Forward. Faster. with Microsoft SQL Server 2012! För övrigt håller vi löpande kurser på just SQL Server 2012 i samarbete med LabCenter under våren då vi går igenom de flesta nyheterna som nu blir tillgängliga för DBA'er och utvecklare.

Få SQL Server hjälp med #sqlhelp

Om du är en SQL Server nörd, och använder twitter känner du säkert till att det finns en blomstrande SQL Server community där. Ifall du inte ännu har testat det, tänkte jag ge lite tips så att du kan komma igång lättare.

Twitter består i grunden av tre element:
1. Du kan registrera dig med ett eget Twitter namn, (Mitt är @SQLSteinar)
2. Du kan följa och skriva till andra twittrare
3. Du kan följa och skriva till/med så kallade hash taggar (Till exempel #sqlhelp eller #sqlserver)

Här följer några tips på SQL Server relaterade hashtaggar och twittrare: Hashtaggar: #sqlhelp (För att begära och ge SQL Server relaterad hjälp till andra twittrare) #sqlserver (Innehåller massor av SQL Server relaterad information) #sqlblog (Länkar till SQL Server relaterade blogg inlägg) #sqlmcm (Info om SQL Server Master programmet) #sqlserver2012 och #sql2012 (SQL Server 2012 såklart...) #sqlfamily och #sqlpeople (Om SQL Server intresserade personer) #sqlpass (PASS, Professional Association for SQL Server, den internationella SQL Server usergroup) #SSRS #SSAS #SSIS (Japp, SSRS, SSAS och SSIS :-)) SQL Server relaterade personer /twitterkonton att följa: EDIT: (Denna lista finns även på Twitter, så blir det lättare att följa alla: https://twitter.com/#!/SQLSteinar/sql-must-follows ) @PaulRandal (Paul Randal) @unclebiguns (Jack Corbett, DBA och SQL Server MVP) @simon_sabin (Simon Sabin, SQL Bits organizer) @MicrosoftBI (Microsofts BI) @DBARoadmap (Guide till att bli SQL Server databas administrator) @jenstirrup (Jen Stirrup, Business Intelligence) @kekline (Kevin Kline) @GlennAlanBerry (Glenn Berry) @SQLSoldier (Robert Davis, PM för SQL Server MCM programmet) @thomaskejser (Thomas Kejser) @mark_sqlcat (Mark Souza, SQL Server General Manager) @improvedk (Mark Rasmussen, upphovsman till OrcaMDF) @sqlcat (SQL Customer Advisory Teamet) @AdamMachanic (Adam Machanic) @BrentO (Brent Ozar) @SQLGoddess (Pam Lahoud, SQL Server MCM) @h_winther (Håkan Winther, SQL Server geni och Vice VD på SQL Service) @AaronBertrand (Aaron Bertrand, SQL Server MVP) @DBArgenis (Argenis Fernandez, Microsoft Certified Master för SQL Server 2008) @banerjeeamit (Microsoft Premier Field Engineer. Bidrar till SQL Nexus/Diag Manager) @SSWUGorg (SSWUG.ORG) @sqlqueen (Kalen Delaney) @statisticsio (Jason Massie, SQL Server MVP) @rob_farley (Rob Farley, SQL Server MVP) @way0utwest (Steve Jones, Editor, SQLServerCentral.com) @Phil_Factor (MystiskSQL Server kändis) @TimCost (Business Intelligence, T-SQL och Tableu) @frozenfishes (Svensk SQL Server DBA) @MidnightDBA (2 SQL Server DBA'er som är gifta med varandra) @SQLSteinar (Mig!) @HanSQL (SQL Server DBA specialicerad på administration och SSIS) @SQLTechCenter (SQL Server TechNet TechCenter) @bobbeauch (Bob Beauchemin) @SirSQL (Nicholas Cain, SQL DBA Nörd) @sqlagentman (Tim Ford, Microsoft SQL Server DBA och MVP) @buckwoody (Buck Woody) @sqlpass (PASS) @SQLChicken (Jorge Segarra, SQL Server MVP och mycket flitig twittrare) och såklart: @SQLServer Lycka till!

Cannot retrieve trace defintion for SQL Server version

Ett vanligt fel när man skall använda SQL Server Profiler mot Analysis Server är detta meddelande "Cannot retrieve trace defintion for SQL Server version ...".

Detta är en rapporterad bugg till Microsoft som ännu inte fått någon lösning. Förhoppningsvis får vi en lösning på detta i en framtida uppdatering. Som tur var finns det dock ett enkelt sätt komma runt detta fel. Detta genom att ändra "Regional Settings" till "English(United States)" och sedan tillbaka till det ursprungliga språket. Därefter är det möjligt att använda profiler'n även mot Analysis Server. Detta är en också en förutsättning för att även kunna optimera och förbättra sina kuber att veta vad som egentligen händer med frågorna.

SQL Server versioner

Ibland kan det vara bra att ha en översikt över vilka versioner av SQL Server som finns gällande service packar, hotfixar och uppdateringar. Jag kan även tänka mig att gå ett steg längre och säga att som SQL Server DBA måste man ha koll på de senaste uppdateringarna. Nedanstående länk innehåller information om hur man tar reda på vilken version man använder. Här finns även en sammanställning av alla uppdateringar som släppts fram till nu: http://support.microsoft.com/kb/321185 Nedanstående länk innehåller också en sammanställning av alla uppdateringar men denna har även en länk för varje uppdatering så man kan läsa mer och ladda ner: http://sqlserverbuilds.blogspot.com/

SQL server - Auto update stats part 3

This is a sequal to previous blog posts about auto update stats in SQL Server, but the focus of this post is how to handle when you know for sure that the statistics will be out of date when you depend on it. As I mentioned in previous blog post, you could use the OPTIMIZE FOR UNKNOWN, but there is some other issues with this query hint. The hint is applied on all tables in your select, even if there are only one table with bad statistics. That means that you might get a good plan, but probably not the most optimal plan. If you know for sure that you always will get more records from one of the tables than what the optimizer will estimate depending on the statistics, you can try to hint the optimizer to use a hash join instead of a nested loop. Well, is hash join faster than nested loop? It depends, nested loop is much faster than hash match when handling few records, and vice versa. I am not a fan of hints in SQL server, but sometimes a hint can perform miracles (at least for a while).

You can try the impact of having missguiding statistics by using the following code:

SET NOCOUNT ON; SELECT * FROM Production.Product P INNER JOIN Production.TransactionHistoryArchive tha ON P.ProductID=tha.ProductID WHERE P.DaysToManufacture>3 UPDATE Production.Product SET DaysToManufacture=10 WHERE ProductID=875 SELECT * FROM Production.Product P INNER JOIN Production.TransactionHistoryArchive tha ON P.ProductID=tha.ProductID WHERE P.DaysToManufacture>=10 ALTER DATABASE AdventureWorks2008R2 SET AUTO_UPDATE_STATISTICS OFF; BEGIN TRAN UPDATE Production.Product SET DaysToManufacture=10 SET STATISTICS IO ON; SET STATISTICS TIME ON; SELECT * FROM Production.Product P INNER JOIN Production.TransactionHistoryArchive tha ON P.ProductID=tha.ProductID WHERE P.DaysToManufacture>=10 SELECT * FROM Production.Product P INNER HASH JOIN Production.TransactionHistoryArchive tha ON P.ProductID=tha.ProductID WHERE P.DaysToManufacture>=10 UPDATE STATISTICS Production.Product; SELECT * FROM Production.Product P INNER JOIN Production.TransactionHistoryArchive tha ON P.ProductID=tha.ProductID WHERE P.DaysToManufacture>=10 SET STATISTICS IO OFF; SET STATISTICS TIME OFF; ROLLBACK TRAN ALTER DATABASE AdventureWorks2008R2 SET AUTO_UPDATE_STATISTICS ON;

As you can see, when the optimizer thinks that there are few records in the product table that matches your condition, it creates a plan with nested loop and you should take a look at the number of logical reads in that case. When you force the HASH join the number of logical reads decreases and when you update the statistics the optimizer choose the hash join by itself.

I am not saying that you should turn of auto update statistics, I am saying that you can get performance issues in some cases if you rely on the automatic updates.

SQL server performance - Death by correlated subqueries

There are many different methods to kill SQL server performance and one of the most bullet proof methods is correleated subqueries. In this blog post I'll try to explain what correlated subqueries are, why they kill the performance and how to avoid them.

First of all, what is a correlated subquery?

Well, it's an inner query that is filtered by values from the outer query. Crystal Clear? Not really, lets give an example instead. First of all, I create two tables .... CREATE TABLE table1 ( col1 INT IDENTITY(1,1) NOT NULL, col2 DATE NOT NULL ) CREATE TABLE table2 ( col1 INT IDENTITY(100000,1) NOT NULL, col2 DATE NOT NULL ) ...and then I write a correlated subquery... SELECT T1.COL2, (SELECT t2.[col1] FROM [table2] AS t2 WHERE t2.[col2]=t1.[col2]) AS col1 --The inner query that is correlated with the outer query INTO #TABLE3 FROM [table1] AS T1 Does this make sense? Well, as you can see, for every record in table1 I'll want to get a record from table2 that is matching on col2. As a matter of fact, this query will fail if table2 will return more than one record for any of the records in table1. Do you see any problem with this approach? Well, in this case, if you execute the code, you will not have any performance issues as the tables are empty, but what will happen if you add a large number of records? You'll kill the SQL server performance!

Why do correlated subqueries kill the performance?

Well, for every record you add in table1, SQL server has to execute the inner query in a nested loop. Lets add some data! In this case I add 1 000 000 records in table1 and table2, just for fun and to show the consequences. ;WITH cteNums AS( -- I use this common table expression to create a list of numbers from 1 to 1 000 000 SELECT top 1000000 ROW_NUMBER() OVER(ORDER BY o1.object_ID) AS n FROM master.sys.columns o1 CROSS JOIN master.sys.columns o2 CROSS JOIN master.sys.columns o3 ) INSERT INTO table1 (col2) --insert into table1 OUTPUT INSERTED.col2 INTO table2 (col2) --use the output clause to insert into table2 SELECT DATEADD(d,n,GETDATE()) -- create dates from the list of numbers FROM cteNums; Now I have two tables with 1 000 000 records in each, they contain the same set of data and it's time to compare a correlate subquery with a simple join. SET STATISTICS IO ON; SET STATISTICS TIME ON; DBCC DROPCLEANBUFFERS; --first use a correlated subquery to populate a temp table to avoid the data transfer to the client SELECT T1.COL2, (SELECT t2.[col1] FROM [table2] AS t2 WHERE t2.[col2]=t1.[col2]) AS col1 INTO #TABLE3 FROM [table1] AS T1 DBCC DROPCLEANBUFFERS; --second use a simple join to populate a temp table to avoid the data transfer to the client SELECT T1.COL2, T3.col1 INTO #TABLE4 FROM [table1] AS T1 INNER JOIN (SELECT t2.[col1],T2.COL2 FROM [table2] AS t2) AS t3 ON T3.[col2]=t1.[col2] SET STATISTICS TIME OFF; SET STATISTICS IO OFF; DROP TABLE [#table3] DROP TABLE [#table4] If you click the button "include actual execution plan" before you execute the code, you would get something like this:

As you can see, two completely different execution plans and according to Management Studio the cost of the first query is about 90% of the complete batch! Well, this is the estimate cost and may or may not reflect the reallity, but don't forget that SQL server is using cost based optimizations to get "the best" execution plan. Anyway, estimated cost or not, it's no rocket sience to understand that the second query is faster. To understand the difference, you can take a look at the join operators, nested loops vs hash match. When you have a nested loop you are going to execute the bottom branch for every record in the top branch. With the hash match join you get a result from both branches and match them together. If you need evidence for that statement you can hover with the mouse pointer over the index spool operator and "voilá"!

As you can see in this popup is that this operation is executed 1 000 000 times, and this is only a "reformatting" of data into a temporary index. The actual join operation is performed in the nested loop. In the second execution plan you can see that you have to table scans with a hash match and the table scans are only performed once. What impact did the execution plans have on elapsed time and number of reads? Well lets take a look at that! I guess you will not be surprised by now. -- I add some options for the index to increase the read performance, you should avoid these settings in a "normal" table, --but in temp tables you can actually gain some performance as the indexes will be compact and --SQL server doesn't need to care about row or page locks CREATE CLUSTERED INDEX IX1 ON [table1] (COL2) WITH(FILLFACTOR=100, PAD_INDEX=ON, ALLOW_ROW_LOCKS=OFF, ALLOW_PAGE_LOCKS=OFF) CREATE CLUSTERED INDEX IX1 ON [table2] (COL2) WITH(FILLFACTOR=100, PAD_INDEX=ON, ALLOW_ROW_LOCKS=OFF, ALLOW_PAGE_LOCKS=OFF) DROP TABLE [#table3] DROP TABLE [#table4] SET STATISTICS TIME ON; SET STATISTICS IO ON; DBCC DROPCLEANBUFFERS; SELECT T1.COL2, (SELECT t2.[col1] FROM [table2] AS t2 WHERE t2.[col2]=t1.[col2]) AS col1 INTO #TABLE3 FROM [table1] AS T1 DBCC DROPCLEANBUFFERS; SELECT T1.COL2, T3.col1 INTO #TABLE4 FROM [table1] AS T1 INNER JOIN (SELECT t2.[col1],T2.COL2 FROM [table2] AS t2) AS t3 ON T3.[col2]=t1.[col2] SET STATISTICS TIME OFF; SET STATISTICS IO OFF;

As you can see, the queries executes much faster with the clustered indexes, but the number of executions and the logical reads are still high and might affect the performance. Another thing to be aware of is that the correlated subquery migth return NULL if there are no match in the inner query and if that is the intended behaviour you need to change the INNER JOIN to a LEFT JOIN to get the same behaviour.

Enable parallellism for specific query

Many times when we work with SQL Server based applications, we solve performance problems by adjusting parallellism settings to limit the genereration of parallell query plans. However, sometimes we need to do the opposite, that is allow certain queries to run with a parallell plan even if the server settings restrict or disable it. There are two settings that control this: Max Degree of Parallellism wich limits the number of worker threads that the individual operators in the query plan can use, and Cost Threshold for parallellism, wich defines the query plan cost limit beyond wich SQL Server starts evaluating parallell plans. So if you want to limit your query plan to use 2 CPU cores/Worker threads per operator you would use OPTION (MAXDOP 2) in the query. But what if you would like SQL Server to always allow parallell plans for this particular query only? This is not so well known, but there are actually an undocumented trace flag that will help you with that. I is called 8649 and what it does is effectively the same as setting Cost Threshold for parallellism to 0. But how do we do that for just one query? Well, we combine the trace flag with the QUERYTRACEON option, and viola :-) The syntax is OPTION (QUERYTRACEON 8649)

24 Hours of PASS: SQL Server 2012

Snart är det dags för 24 Hours of PASS: SQL Server 2012. Under ett helt dygn hålls 24 stycken sessioner om SQL Server. Datumet för detta är den 21/3 så passa på att registrera er för intressanta dragningar varav många förstås handlar om SQL Server 2012. Tänk att få lära sig mer om "SSIS Tips & Tricks" vid midnatt eller 4 timmar senare lära sig mer om några gratisverktyg som man kan använda för att förbättra prestandan av sin SQL Server miljö. Dygnet avslutas med session om den stora nyheten "Always On". Ett tips är att registrera sig snabbt eftersom antalet platser är begränsat. Allt är också gratis. Det finns också ett utmärkt tillfälle att lära sig mer om "Always On" och andra nyheter och annat i egna labbar som vi håller tillsammans med Lab Center.

AUTO_UPDATE_STATISTICS

Eftersom statistik verkar vara ett hett ämne just nu :-) ... så tänkte jag spinna vidare lite på det temat. Om man har AUTO_UPDATE_STATISTICS påslaget i databasen kommer automatiskt all statistik uppdateras. Detta är bra och smidigt eftersom all statistik automatiskt underhålls men om man av någon anledning har en eller flera tabeller, kolumner eller index där man inte vill uppdatera statistiken automatiskt eller vill uppdatera statistiken med andra värden på t. ex. sample rate än övriga pga att tabellen är väldigt stor eller något annat kan man undanta dessa.

Detta gör man såhär: EXEC SP_AUTOSTATS 'Tabellnamn', OFF, 'Indexnamn'; Ovanstående undantar automatisk uppdatering av statistik på specifikt index i en tabell. Man kan även använda sp_autostats för att visa hur autostats är inställd för all statistik på en specifik tabell. EXEC SP_AUTOSTATS 'Tabellnamn'; Detta är såklart inte enda sättet att undanta statistik från att bli auto uppdaterad, man kan även använda: CREATE STATISTICS Tabellnamn Statistiknamn WITH NORECOMPUTE; Om man skapar statistiken manuellt. Eller om man redan skapat statistiken: UPDATE STATISTICS Tabellnamn Statistiknamn WITH NORECOMPUTE; Eller ett redan skapat index: ALTER INDEX Indexnamn ON Tabellnamn SET (STATISTICS_NORECOMPUTE = ON); AUTO_UPDATE_STATISTICS är en inställning på databasnivå och för att se hur detta är inställt kan man antingen titta i Management Studio under properties/options eller köra: SELECT is_auto_update_stats_on FROM sys.databases WHERE name = 'Databasnamn'

SQL server - Auto update stats part 2

The last week I posted a blog about auto update stats and this is a sequal to that blog post. I case you haven't read it you should read it first. If you tried the script last week, you noticed that :

- the statistics didn't update when the data was added
- the statistics didn't update when you selected from the table unless you recompiled the procedure.
- the less accurat statistics was the larger difference between estimated and actual number of records was.
- the statistics was updated when you recompiled the procedure, selected from the table and at least 20% of the data was changed
- the statistics updated less frequent when more data was added. 20% of 100 000 records is a lot more than 20% of 10 000 records.

If this would have been a real case scenario you would probably get into some serious performance problem as the statistics become inaccurat and the procedure get a new execution plan for some reason. The execution plan may get flushed from the cache due to some memory constraint and the procedure gets compiled with the assumption that you have less record than you actually have. The problem gets even worse when the data in the index is incrementing and you wants to get the last added records. Lets assume you want to get the last 19% of a table with 100 000 000 of records and the statistics is out of date. You want to get 19 000 000 records and SQL server statistics estimate the number of records of 1! That's a big difference and SQL server will give you a plan that would use a nested loop instead of a merge or hash join when joining a second table. The nested loop gets executed 19 000 000 times instead of the estimated 1. Should you depend on the auto update stats? Well, the short answer is, "it depends". I guess you've heard that before. In most cases auto update stats is a good thing, but in some cases you have to force the update stats by yourself. One good thing is that statistics are updated when you rebuild your indexes, BUT it's not updated when you reorganize the indexes. I guess some of you always rebuild all your indexes on a regular bases, and some of you are using a smart script to rebuild or reorganize your indexes depending of the fragmentation. If you are using a smart script you can get some serious trouble, because not every index gets fragmented! An index with data that is increasing, like an identity column, adds data in the last page and creates a new one when it's full. And if the index doesn't get fragmented, it will not be rebuilt with your script and the statistics will not be updated.

If this is your case, you have a couple of options:

- Schedule an update statisticse
- Add update statistics in a procedure that you know is depending on fresh statistics
- Add the trace flag 2371 to change the threshold for the auto update stats. The threshold will change depending on the amount of data that exist in the table. You can read more about about the trace flag here

Enable the trace flag with: DBCC TRACEON(2371) Execute the code from my previous post and compare with previous results and you can see that the statistics are updated more frequent. I have seen some terrible issues with bad statistics, like a procedure that took about 7hours to execute. After adding update stats in the procedure it took only a couple of minutes.

If you are having performance issues with your SQL server, call us and our SQL server consultants will do what they can to investigate and solve your issues.

Optimizing performance of UPDATE STATISTICS

Recently while working on a TB size SQL Server database, I got the opportunity to verify something that I have suspected for some time, but not yet looked into properly.

I am talking about how to optimize UPDATE STATISTICS performance by utilizing the SQL Server 2008 R2 Enterprise Edition Compression feature. It is a common scenario today to have a SQL Server cluster with plenty of CPU available, on top of SAN disks. So too in this case. And usually, you tend to be IO bound in this scenario. The problem escalates when your tables are so big that they do not fit in the cache. And what seems to happen when you rebuild statistics on a table is that the statistics are rebuild one by one.

So if you for example have statistics on 10 columns (index statistics aside), SQL Server will scan the table for the first column (from disk mostly), updating the statistics. But since the table does not fit in memory, when the time comes to scan the table to find information about the second column, the table have to be read from disk again. And so on for every column. Obviously this is a slow and tedious process. But what happens if you compress your tables, specifically the clustered index of your big tables? The theory is that since the table/index will stay compressed in memory as well, more of the table should fit there at one, dramatically speeding up the process described in the previous paragraph. And as mentioned, I finally got around to verifying this in a real production environment.

The result? Absolutely fantastic! I saw a 5 - 8 times improvement in running "UPDATE STATISTICS WITH SAMPLE 40 PERCENT" wich is what we use at this particular customer. And that just from enabling a feature that the customer had already paid for, and is completely transparent to the application. There are a lot of other advantages to SQL Server compression (and other enterprise features), but more on that later :-)

If you need SQL Server assistance, don't hesitate to contact us!

Auto Shrink = True

Som jag skrivit tidigare så skall man aldrig ha Auto Shrink aktiverat för någon databas i sin SQL Server miljö. Hur detta kan slå i kombination med Auto Grow visar jag längre ned detta blogginlägg. Att Auto Shrink överhuvudtaget finns kvar brukar man säga beror på bakåtkompatibilitet med tidigare SQL Server versioner. Det är också sällan man hör någon vara så missnöjd men sin kod som Paul Randal är över Auto Shrink. För att konstatera om någon databas har Auto Shrink aktiverat kan man använda denna SQL: SELECT name, is_auto_shrink_on FROM sys.databases WHERE is_auto_shrink_on = 1

Skulle så vara fallet så ändrar man detta med : ALTER DATABASE [databasnamn] SET AUTO_SHRINK OFF WITH NO_WAIT

Nu till vilka följder detta kan få. Ett enkelt sätt att se historiks hur data/loggfilerna växt/krympt är att att använda standardrapporten Disk Usage i Management Studio.

Dock är det så att denna rapport inte att går att köra om man har en databas i komptabilitetslägen 80, dvs SQL Server 2000.

I stället kan man använda nedanstående SQL. exec sp_executesql @stmt=N'begin try if (select convert(int,value_in_use) from sys.configurations where name = ''default trace enabled'' ) = 1 begin declare @curr_tracefilename varchar(500) ; declare @base_tracefilename varchar(500) ; declare @indx int ; select @curr_tracefilename = path from sys.traces where is_default = 1 ; set @curr_tracefilename = reverse(@curr_tracefilename); select @indx = patindex(''%\%'', @curr_tracefilename) ; set @curr_tracefilename = reverse(@curr_tracefilename) ; set @base_tracefilename = left( @curr_tracefilename,len(@curr_tracefilename) - @indx) + ''\log.trc'' ; select case convert(int, EventClass) when 92 then ''Data File Auto Grow'' when 93 then ''Log File Auto Grow'' when 94 then ''Data File Auto Shrink'' when 95 then ''Log File Auto Shrink'' end as EventClass , (Duration/1000) as Duration , StartTime , EndTime , (IntegerData*8.0/1024) as ChangeInSize from ::fn_trace_gettable( @base_tracefilename, default ) where EventClass >= 92 and EventClass order by StartTime desc ; end else select -1 as l1, 0 as EventClass, 0 DatabaseName, 0 as Filename, 0 as Duration, 0 as StartTime, 0 as EndTime,0 as ChangeInSize end try begin catch select -100 as l1 , ERROR_NUMBER() as EventClass , ERROR_SEVERITY() DatabaseName , ERROR_STATE() as Filename , ERROR_MESSAGE() as Duration , 1 as StartTime, 1 as EndTime,1 as ChangeInSize end catch',@params=N'' Till slut kommer här en av anledningarna till varför man inte skall sätta Auto Shrink = True. Som ni kan se av bilden nedan är det rätt avsevärd tid som går åt för att loggfilen i det här fallet skall växa och därefter krympa i ett snurrande ekorrhjul.

Extended Stored Procedures

I guess most of you don't use Extended Stored Procedures any more since we now can and should use CLR integration instead. CLR integration has been around since version 2005 so this is old news, but, as a matter of fact Extended Stored Procedures are deprecated and will be removed in the next release of SQL Server. Because of this it's now time to once and for all stop using Extended Stored Procedures and a good place to start is to unload the dll file called by running: EXECUTE DBCC dllname (FREE) This command will unload the dll file from memory and make it possible to remove the Extended Stored Procedure. I know that it's not always easy to just stop using specific features so this command is also useful if you want to replace the dll file with a newer one for some reason. To get a list of all Extended Stored Procedures and the name of the dll file that the procedure belongs to you can run: EXECUTE sp_helpextendedproc If you want to know more about this or some other SQL Server related topic just contact any of our SQL Server consultants.

SQL server - Auto update stats part 1

In the last couple of weeks I've been helping one of our clients with some performance issues in a stored procedure. Some days it works well and some days it doesn't. After some investigations I found two different execution plans, and the unefficient plan indicated that only one record was returned for some of the tables, but in the reality they returns a couple of hundreds of thousands.

This is a common problem when the statistics are out of date and you can read more about the problem at my earlier blog post, but what about auto update stats. Doesn't it work? Well it does, the statistics are updated when more than 20% of the data is changed, but in this case we loads a datawarehouse with new data every day and the procedure that doesn't perform well only operates on new data. Some of the tables contains >3oo ooo ooo records and 20% of the data is a 60 000 000 records, and that means that the statistics are not updated every day.

The problem is that the procedure recompiles everytime and is using out of date statistics to create an execution plan. If you want to learn more about auto update stats you can try the attached script.

CREATE FUNCTION [dbo].[fnNumsTable](@pStartValue BIGINT= 1,@pEndValue BIGINT= 1000000,@pIncrement BIGINT= 1) RETURNS TABLE AS -- + --------------------------------------------------------------------------------------------------------------- -- ! O b j e c t i v e : Return a list of all numbers between startvalue to end value -- ! The table may be used to avoid cursors, generate a list of dates etc. -- +----------------------------------------------------------------------------------------------------------------

--Select n from dbo.[fnNumsTable](1000,2000,1) RETURN( WITH BaseNum(N) AS ( SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 ), L1(N) AS ( SELECT bn1.N FROM BaseNum bn1 CROSS JOIN BaseNum bn2 ), L2(N) AS ( SELECT a1.N FROM L1 a1 CROSS JOIN L1 a2 ), L3(N) AS ( SELECT TOP ((ABS(CASE WHEN @pStartValue < @pEndValue THEN @pEndValue ELSE @pStartValue END - CASE WHEN @pStartValue < @pEndValue THEN @pStartValue ELSE @pEndValue END))/ABS(@pIncrement)+ 1) a1.N FROM L2 a1 CROSS JOIN L2 a2 ), Tally(N) AS ( SELECT row_number() OVER (ORDER BY a1.N) FROM L3 a1 ) SELECT ((N - 1) * @pIncrement) + @pStartValue AS N FROM Tally ); GO CREATE TABLE dbo.statsSample ( ID int IDENTITY(1,1) NOT NULL, repDate DATE NOT NULL ); GO CREATE CLUSTERED INDEX ix ON dbo.statsSample ( ID )WITH (FILLFACTOR=100, ALLOW_ROW_LOCKS=ON, ALLOW_ROW_LOCKS=ON); GO CREATE PROCEDURE dbo.spStatsTest @records INT, @count int out, @statsdate datetime out --WITH recompile AS SET NOCOUNT ON; INSERT INTO dbo.statsSample ( repDate ) SELECT DATEADD(D,N,GETDATE()) FROM SQLServiceTools.dbo.fnNumsTable(1,@records,-1); SELECT @count = COUNT(1) FROM dbo.statsSample WHERE ID >0; SELECT @statsdate=STATS_DATE(i.object_id, i.index_id) FROM sys.indexes i WHERE i.object_id=OBJECT_ID('dbo.statsSample'); GO DECLARE @x INT = 0; DECLARE @initialrecords INT = 10000; DECLARE @increment INT =2000; DECLARE @STATSDATE DATETIME; DECLARE @COUNT INT; DECLARE @PREVSTATSDATE DATETIME; SET NOCOUNT ON; EXEC dbo.spStatsTest @initialrecords,@COUNT OUT,@STATSDATE OUT; SELECT @PREVSTATSDATE = ISNULL(@STATSDATE, GETDATE()); WHILE @x <@initialrecords BEGIN EXEC dbo.spStatsTest @increment,@COUNT OUT,@STATSDATE OUT; --INSERT INTO dbo.statsSample --( -- repDate --) --SELECT DATEADD(D,N,GETDATE()) --FROM dbo.fnNumsTable(1,@increment,-1) -- SELECT @count = COUNT(1) -- FROM dbo.statsSample -- WHERE ID >0 --SELECT @statsdate=STATS_DATE(i.object_id, i.index_id) --FROM sys.indexes i --WHERE i.object_id=OBJECT_ID('dbo.statsSample'); IF @PREVSTATSDATE<> @STATSDATE BEGIN --return the recordcount and the time of the stats update SELECT @COUNT,@STATSDATE; SELECT @PREVSTATSDATE = @STATSDATE END SET @x+=@increment/10; END DROP TABLE dbo.statsSample; DROP PROCEDURE dbo.spStatsTest;

As you can see in this test is that the statistics are not updated in the procedure as long as the procedure doesn't recompile. If you add the WITH RECOMPILE in the procedure, the statistics are auto updated when you select from the table and 20% of the data have been updated/inserted. The more records you add, the less frequent statistics updates you get. The worst part in this test is the bad execution plan. Take a look at the execution plan when you don't recompile the procedure, you'll notice that SQL server reports estimated number of records =1, but in the worst case, you have 100 000 records. Should you depend on AUTO UPDATE STATS? Well, get back next week, and I'll post a new blog post about auto update stats.

Improving Performance by not querying the database?

Did you ever think that it would be great to cache SQL Server database query results, and only go back to query the database when data has changed? Well, you can do that, using Query Notifications. Query notifications were introduced as early as in SQL Server 2005. They are built upon the Service Broker infrastructure introduced in SQL Server 2005. Query notifications allow applications to be notified when data has changed.

This feature is particularly useful for applications that provide a cache of information from a database, such as a Web application, and need to be notified when the source data is changed. You still have to connect to the Service Broker Queue using the RECIEVE command, but that query would usually be much lighter that the query that you want notification for. No point in using Query Notifications for small quick queries with rapidly changing results, but rather for a little heavier queries that does not change it's results that often. Query notifications allow you to request notification within a specified time-out period when the underlying data of a query changes. The request for notification specifies the notification options, which include the service name, message text, and time-out value to the server.

Notifications are delivered through a Service Broker queue that your applications can poll for available notifications. Notifications are sent only once. For continuous notification of data change, a new subscription must be created by re-executing the query after each notification is processed. More information about Query Notification can be found here.

And dont hesitate to contact us if you have any SQL Server related questions!

A SQL Azure tip a day (21) - Security services

If you are worried about the security of SQL Azure, there is an early prototype of SQL Azure Security Services that you can use to scan your database to find any vulnerabilities. It is an easy to use Web application that will give you a report in your web browser or in your Azure storage. If the SQL Azure Security Services finds any security issues, you'll get a description and the a recommendation of how to fix the problem. It is nice to find the security threats that exists in my database, but I would also like to see all the security threats that doesn't exists in my database. For my database there was only reported one issue, but I can't see what vulnerabilities that have been tested and that makes me worried. Does the Security Services test all the possible threats? Well, it's an early prototype and the final version may be more informative.

QUERYTRACEON

Att man kan slå på traceflaggor på global nivå eller sessionsnivå vet väl de flesta, men det kan vara bra att veta att man även kan slå på traceflaggor på statement nivå. För att göra det använder man sig av en hint som heter QUERYTRACEON. T. ex. med traceflagga 3604 samt XXXX och YYYY: SELECT FROM Table WHERE ORDER BY OPTION ( QUERYTRACEON 3604, QUERYTRACEON XXXX, QUERYTRACEON YYYY ) Där traceflagga 3604 används för att skicka trace output till klienten och XXXX samt YYYY kan vara andra traceflaggor.

SQL Server 2012 release event.

Den 7 Mars 2012 så anordnar Microsoft en virtuell release event, läs mer om denna här : http://www.sqlserverlaunch.com/ww/Home

Nyheterna i SQL server 2012 är så efterlängtade att flera av våra kunder redan har börjat förbereda sig för releasen så att de snabbt kan uppgradera sina miljöer när den finns tillgänglig. Vill du veta mer om nyheterna och vad SQL Server 2012 kan innebära för dig så är du välkommen att kontakta våra SQL server konsulter som gärna går igenom den med dig. Vi har även tillsammans med Labcenter tagit fram 2st 3dagars labbar inom SQL server programmering och SQL server administration. Läs mer om dessa på Labcenter

Request_session_id = - 2 ?

En av de många fördelar när man jobbar som konsult hos oss är att man får se olika miljöer och olika verksamheter. Ofta kan våra kunder ha likartade problem men så är inte alltid fallet. Ibland stöter man på problem som är rätt ovanliga, märkliga och inte alltid helt lätt att hitta lösningen till heller.

Här kommer ett exempel på detta. Om man upptäcker att loggfilen är större än datafilen bör man kontrollera vad detta beror på. En troliga orsak är att det finns aktiva transaktioner som inte avslutats som man kan se nedan. select name, log_reuse_wait_desc from sys.databases Ger detta resultat name log_reuse_wait_desc DBxxx ACTIVE_TRANSACTION Nästa steg blir då att kontrollera den äldsta transaktionen och förhoppningsvis avsluta den så att inte loggfilen fortsätter växa. För att hitta transaktionen använder man DBCC OPENTRAN, och detta kan ge följande resultat: Oldest active transaction: SPID (server process ID): 60 UID (user ID) : -1 Name : offline index build LSN : (109581:2986:82) Start time : Jan 12 2012 10:31:04:337PM SID : 0x0 DBCC execution completed. If DBCC printed error messages, contact your system administrator.

Som regel vill man avsluta en så gammal transaktionen som i det här fallet , dvs SPID = 60 och detta gör man med KILL. Innan man gör det vill man förstås kontrollera vilken kod som kan vara orsak till den aktiva transaktionen och för detta använder man DBCC INPUTBUFFER. Nu börjar det intressanta. Detta kan nämligen inte vara samma transaktion som vi är ute efter. Kan det då vara en sk. Orphaned MSDTC transactions som är mycket bra beskriven här och som många refererar till t.ex. Paul Randall. Nu finns en chans att vi kan använda request_owner_guid och därefter KILL. SELECT sys.databases.database_id, sys.databases.name, sys.dm_tran_locks.request_owner_guid FROM sys.dm_tran_locks INNER JOIN sys.databases ON sys.dm_tran_locks.resource_database_id = sys.databases.database_id WHERE sys.dm_tran_locks.request_session_id = - 2 Nej, detta hjälper inte med '00000000-0000-0000-0000-000000000000' som request_owner_guid.

Vi testar då till slut att starta om SQL Serverns tjänster och också omstart av msdtc, men inte heller detta hjälper i det här fallet. Nästan direkt efter omstart kommer vår "felaktiga transaktion" som nu leder oss mot fulltext index mha fn_dblog som innebär att vi kan läsa från transaktionsloggen. Nästa steg blir nu att kontrollera alla fulltext index för databasen. Detta visar något mycket märkligt, nämligen att dessa är uppdaterade så länge sedan som under 2009. Normalt skall detta ske vid t.ex. insert. När index är uppdaterade kan man se enkelt med nedastående SQL-sats. SELECT sch.name AS SchemaName, t.name AS TableName, c.name AS FTCatalogName, i.has_crawl_completed, i.crawl_start_date, i.crawl_end_date FROM sys.tables t JOIN sys.fulltext_indexes i ON t.object_id = i.object_id JOIN sys.fulltext_catalogs c ON i.fulltext_catalog_id = c.fulltext_catalog_id JOIN sys.schemas sch ON sch.schema_id = t.schema_id ORDER BY SchemaName, TableName Vad händer då om vi bygger om index'ena med ALTER FULLTEXT CATALOG xxx REBUILD ?.

Jo, crawl_start_date och crawl_end_date uppdateras nu med dagens datum. Dock har vi kvar våran Active Transaction, men inte länge till. För efter en omstart av SQL Server så är allt nu ok :-). Som sagt, ibland kan en felsökning bestå av många tester och antaganden innan man till slut hittar den slutgilitga orsaken.

Mirroring related Error: 3624, Severity: 20, State: 1

Recently, I had the pleasure of troubleshooting several Error 3624 on a SQL Server 2008 R2 instance. It seems to be related to bulk copying in data to a principal database in a mirroring setup. The principal never runs into trouble, but the mirror database generates an error when trying to replay the transactions. It tries to initiate a lock escalation, but fails for some unknown reason. The mirroring session is then suspended, and will have to be reinitialized from start. From this Microsoft Knowledgebase article http://support.microsoft.com/kb/974319 it seems that this problem should be fixed in CU1 for SQL Server 2008 R2. But we got the exact same problem even though we were running on SP1 (10.50.2500). So it seems that this error might have resurfaced, or that there exists a similar bug still. If you run into this problem, with SP1 installed, you should contact Microsoft Support. In the meantime, two workarounds should be possible. Either do a regular insert instead of an Bulk Insert, or you can break mirror beforehand and reinit it after the bulk insert operation.

If you need help with SQL Server, we are always happy to help!

Begin Distributed Transaction

A transaction is a essential part of every database/application. If a transaction involves more than one server it becomes distributed and this is where MS DTC comes into play. The first step to make a distributed transaction work is to make sure SQL Server can enlist in the local MS DTC and a good place to start is to run the following in Management Studio: BEGIN DISTRIBUTED TRANSACTION If MS DTC is not installed or not working properly the above statement will produce an error message and you need to solve this before you can go ahead and test transactions against other servers. Once the local transaction coordinator is working there are some tools to check if MS DTC is working properly with other servers. DTC PING is a tool that is used to check that certain ports are open and that name resolution works, if you for example need to run distributed transactions through a firewall.

It can be downloaded here: http://www.microsoft.com/download/en/details.aspx?id=2868 DTC TESTER is another tool that actually creates and runs a dummy distributed transaction.

Over the years i've found this tool very reliable and in my experience if this works then you won't have any problems running distributed transactions. It can be downloaded here: http://support.microsoft.com/kb/293799

SQL Azure tip a day (20) - Reporting Service

In SQL Azure there is a CTP of Reporting Services for Azure. It is easy to configure and you use the same development tool as you do with SQL Reporting Services 2008. Personally I had some trouble when I uploaded the reports in to the SQL Azure Reporting server through the managment portal, but I may have done something wrong. The good news is that when I deployed the report and the Shared Data Source through Visual Studio 2008 it worked just fine and it was even easier. You install and configure the SQL Azure Reporting Server in 3 simple steps.

1 Create a new SQL Azure Server

Sign in to the managment portal and click the reporting button, and then click the "Create new SQL Azure Reporting Server"

2. Select subscription

To create a new SQL Azure Reporting Server, you need to select your subscription and the region you want. Then click next.

3. Create an administrator account.

As SQL Azure doesn't handle Windows Authentication, you need to create an administrator account and set a password. Once that is done, click next.

If everything works as it should, you now have a Reporting service in the cloud. Simple as that. How long did it take? Well, a couple of minutes.

Logman

Jag har tidigare skrivit om PAL, Performance Analysis For Logs och då nämnt om att man kan använda Logman för att skapa en perfmon-fil.Detta är väldigt användbart och går också snabbt att sätta upp i olika miljöer om man skulle vilja det. För att analysera en blg-fil mha PAL behöver man mätvärden. Dessa sparar man i en textfil som jag i exemplet har döpt till sql_counters.txt och där ni ser några av raderna nedan. \LogicalDisk(*)\Disk Reads/sec \LogicalDisk(*)\Disk Transfers/sec \LogicalDisk(*)\Disk Writes/sec \Memory\% Committed Bytes In Use \Memory\Available MBytes \Memory\Cache Bytes ....

Jag har också en bat-fil, load_sql_counters.bat som innehålla dessa rader: logman stop SQLServer logman delete SQLServer logman create counter SQLServer -cf "c:\Logman\sql_counters.txt" -si 30 -o "C:\Perflog\SQLService_" -b 2012-01-24 09:00 -e 2012-01-24 11:00 -v mmddhhmm -r Inte alltför svår logik som ni ser där jag skapar en data collector, SQLServer som om den redan skulle finnas först stoppar och i så fall tar bort den. Man kan också se att jag använder textfilen med alla mätvärden. Just i det här exemplet ser man inamlingen skall mellan kl 09 och 11 med start 24/1 och därefter upprepas varje dag. Som sagt ett smidigt sätt att aktivera insamling av mätvärden och ett bland många verktyg som man har nytta av när man skall felsöka eller optimera sin SQL Server miljö.

A SQL Azure tip a day (19) - High Availibility

Well, the last blog post from my collegue was causing some attention! Lets make something very clear. We like the SQL Azure concept even if it doesn't sounds like that in some of our blog posts. The purpose of this series of blogs is to share some knowledge that may help you when you are about to move to the Cloud, not to criticize the SQL Azure platform. The performance test from the last blog post was not a real case scenario, but rather a benchmarkt test that you can try for yourself on different SQL server configurations and disk setup to find the best setup for your demands. You can use it to compare between a SAN solution and local HDD:s, between different RAID levels, peek vs off-peek hours, or between SSD vs HDD solutions as long as you do the same test on all of your configurations. The test performed in the previous blog post was during peek hours and you'll get some improvement running the same test in off-peek hours.

The performance measured is about the same as another SQL server connected to a SAN with synchronous replication to a secondary site. but the laptop in the test used as a reference is still about 5 times faster and it is about the same as a local SQL server with internal drives. Waits that we could maesur all had to do with High Availibilty, and of course you can't get High Availibility on your laptop, but in SQL Azure you have 99,9% avalibility. In SQL Azure you have 2 exact kopies of the database. The conclusion is that you'll get High Availibilty at the cost of the ultimate performance. It's no big deal but you have to be aware of it.

If you need more performance in SQL Azure, you can use multiple databases with Federation and multiple connections.

SET OPTIONS

Efter att ha svävat omkring i molnet hela veckan tänkte jag att det nu är dags att komma ner på jorden igen :-) Härom dagen behövde jag snygga till lite data. Eftersom datat laddas om varje vecka så var det ju ett måste att automatisera det hela. Jag bestämde mig för att skapa ett jobb som körs av SQL Server Agent. Själva tillsnyggandet av datat var mycket enkel: UPDATE TraceEvent SET StartTime = DATEADD(DD, DATEDIFF(DD, StartTime, EndTime), StartTime) Alltså inga konstigheter. När jag sedan provkör detta så får jag ett fel: Executed as user: NT AUTHORITY\SYSTEM. UPDATE failed because the following SET options have incorrect settings: 'QUOTED_IDENTIFIER'. Verify that SET options are correct for use with indexed views and/or indexes on computed columns and/or filtered indexes and/or query notifications and/or XML data type methods and/or spatial index operations. [SQLSTATE 42000] (Error 1934). The step failed.

Ok, vad är nu detta? Det fungerade bra när jag testkörde i SSMS, jag har ingen indexerad vy, jag har inga xml datatyper och absolut inga spatiala index....

MEN min tabell innehåller faktiskt en "computed column"! Vad SQL Server säger är att jag har fel SET Options men när jag kör Update skriptet direkt i Management Studio så går det bra, det måste betyda att jag får andra SET Options när jag kör det hela i ett jobb.

Ett enkelt sätt att ta reda på vilka SET Options man har när man kör ett jobb är att lägga in följande i ett jobbsteg: DECLARE @options INT SELECT @options = @@OPTIONS IF ( (1 & @options) = 1 ) PRINT 'DISABLE_DEF_CNST_CHK' IF ( (2 & @options) = 2 ) PRINT 'IMPLICIT_TRANSACTIONS' IF ( (4 & @options) = 4 ) PRINT 'CURSOR_CLOSE_ON_COMMIT' IF ( (8 & @options) = 8 ) PRINT 'ANSI_WARNINGS' IF ( (16 & @options) = 16 ) PRINT 'ANSI_PADDING' IF ( (32 & @options) = 32 ) PRINT 'ANSI_NULLS' IF ( (64 & @options) = 64 ) PRINT 'ARITHABORT' IF ( (128 & @options) = 128 ) PRINT 'ARITHIGNORE' IF ( (256 & @options) = 256 ) PRINT 'QUOTED_IDENTIFIER' IF ( (512 & @options) = 512 ) PRINT 'NOCOUNT' IF ( (1024 & @options) = 1024 ) PRINT 'ANSI_NULL_DFLT_ON' IF ( (2048 & @options) = 2048 ) PRINT 'ANSI_NULL_DFLT_OFF' IF ( (4096 & @options) = 4096 ) PRINT 'CONCAT_NULL_YIELDS_NULL' IF ( (8192 & @options) = 8192 ) PRINT 'NUMERIC_ROUNDABORT' IF ( (16384 & @options) = 16384 ) PRINT 'XACT_ABORT' Printsatserna kommer då att skriva ut de SET Options som gäller och dessa kan man se i "View History" på jobbet. I mitt fall blev resultatet: Executed as user: NT AUTHORITY\SYSTEM. ANSI_WARNINGS [SQLSTATE 01000] (Message 0) ANSI_PADDING [SQLSTATE 01000] (Message 0) ANSI_NULLS [SQLSTATE 01000] (Message 0) ANSI_NULL_DFLT_ON [SQLSTATE 01000] (Message 0) CONCAT_NULL_YIELDS_NULL [SQLSTATE 01000] (Message 0).

The step succeeded. Här kan man då se att QUOTED_IDENTIFIER inte är satt vilket är mitt problem. Allt som behöver göras nu är att ändra jobbet till: SET QUOTED_IDENTIFIER ON GO UPDATE TraceEvent SET StartTime = DATEADD(DD, DATEDIFF(DD, StartTime, EndTime), StartTime)

Nu funkar jobbet som tänkt och allt är återigen frid och fröjd :-)

SQL Azure followup

I have received quite some attention after my previous blog post regarding SQL Azure and INSERT performance. Therefore I would like to comment on some of the questions and issues raised, as well as giving my opinion on SQL Azure amongst other things. I will divide it into two sections, an overall perspective on performance testing and general platform evaluation, and one section about the technical aspects of that particular test. If you are short on time, here is a short summary: Even if the test I performed and reported on in itself is valid and correct, it was a simple test. It tests only one of the many aspects that should be taken into consideration while evaluating performance on SQL Azure, or even indeed on any other SQL Server platform or server. And no, I do not recommend that you run your production SQL Server databases on a laptop :-)

Overall perspective

I do a lot of consulting on SQL Server, and have done for about 16 years, helping customers in all types of projects regarding SQL Server. And in my experience, the more I can base my recommendations on fact, the better the results. Therefore I like to test and verify as many aspects of my recommendations as I can. However, a single test will not give you the answer to what road to take when choosing the database platform that is best for you. Besides from functionality, there are three main areas that should be considered while testing, evaluation and choosing a database platform for your application: Performance, Availability and Cost. Each customer have their own order of priority of course, but generally most of them want as much Performance and Availability as possible, with as little Cost as possible. Of course. The trick is to find the right mix of these three for each customer. And as with most things, it quickly comes down to tradeoffs between the different goals. And the three main areas are themselves of course divided into many sub-areas, which in turn needs to be balanced right for each customer.

Availability

This is the most critical factor, when it really comes down to it. Particularly the Disaster Recovery aspect of it. It can be really, really costly if your database server fails and you can’t recover your data. Every year, companies goes bankrupt for that reason. The good thing is that a real disaster rarely happens, the bad news is that this tends to cause people to view it as less important. But I think that this should be your highest priority, in the sense that you define the maximal data loss and the maximal service loss (in minutes or hours) that you can accept, and design your database platform to meet that criteria. The money you have left in your budget can then go to increasing performance. However, sometimes availability comes at the cost of performance. This can be the case in for example SQL Azure, which always keeps 2 additional copies of your database ~~and at least one of those outside your primary datacenter~~.

EDIT: The copies of the databases are all within the same datacentre. This is synchronous copies, and that adds some overhead. Other forms of High Availability or Disaster Recovery techniques that will add overhead, and therefore decrease performance is SAN discs, Mirroring, and Replication. Logshipping is actually the option that adds the least overhead. But it is also very important to test and verify the choices you make here, such as regularly restoring your backups and checking their consistency, and performing controlled Disaster Recovery scenario exercises.

Performance This area is almost too big to even get started on. But apart from our blog, another good sources of information is http://www.sql-server-performance.com/ . The most critical factor here is the application itself, that is from the database perspective the database model, queries, indexes and design choices such as what data to put inside our outside the database, stored procedures vs ad hoc queries, OR mappers or not, and so on. Then there are the setup and configuration of SQL Server itself, and the server/infrastructure hardware. Once again, testing and verifying the choices you make are important. Make sure that you do it in your test environment before you go into production, it is so much easier and cheaper to remedy any problems in that stage. Many times, IO is the main bottleneck in the hardware. Therefore I usually verify that the discs performs as expected using for example SQLIO, and various scripts, to make sure I know that there are no problems with the setup of the discs. In general you will have to spend a lot more money on a SAN to get even close to the performance you can get from a locally attached array of discs. SSD is great in many respects, but still a bit too pricy for most customers. Adding RAM to your server can greatly offset many IO related bottlenecks, with one exception: Adding, Deleting or Changing data always puts pressure on your transaction log drive, as the operations have to be written to stable media (usually disc) before actually being performed on your data. Evaluating performance of your particular SQL Server and Hardware combo setup, gives insight to what that platform can give you in terms of raw transactions per second, but in reality you will most likely have much to gain from looking long and hard at your application first. But it is good to know what your environment can deliver, after it has been set up and configured as good as it can be.

Cost This is an interesting aspect, that can be dissected in many ways. TCO and ROI are examples of different popular ways of looking at cost. The costs incurred in database platform related projects are usually first upfront costs from hardware, software and man hours and secondly it is the running costs of the platform. This is where SQL Azure can really shine compared to an on-site SQL Server solution. The startup cost for hardware and software are zero. And the running costs are low as well. My tests where run on a 1 GB Web Edition of SQL Azure that costs from $9.99 (https://www.windowsazure.com/sv-se/pricing/calculator/) Startup and running costs for on-premise SQL Server is far higher, even if there is a free version of SQL Server available ( http://www.microsoft.com/sqlserver/en/us/editions/express.aspx ) If you already have an IT infrastructure, or if you require many and large databases, your calculations might be different of course. As always, if you want the best possible solution in terms of performance and availability, be prepared to pay. On the other hand, it might be even more costly if you do not plan and test properly in advance, and implement a solution that actually fills your particular needs.

The technical details First I want to state that you will have to make some changes to the scripts in the previous blogpost to make them run on SQL Azure, as there where index options in there that is not supported on SQL Azure. But that was just due to the fact that I scripted out the indexes using SSMS from SQL Server 2008 R2. That makes no difference to the actual test however. So, to address some of the questions regarding the actual test, I have compiled a little list of Q&A: - Q: Use newsequentialid() instead of newid(). A: That is not possible, as newsequentialid() is not supported yet on SQL Azure - Q: Change the Clustered Index to to on the INT_COL column instead. A: I haven’t tested this, but I suspect it might impact the amount of transaction log that we create quite a lot (see http://sqlskills.com/BLOGS/PAUL/post/How-expensive-are-page-splits-in-terms-of-transaction-log.aspx) But in fairness, that improvement would also benefit the other system. The test was deliberately designed to be though, so that differences in results would be easier to spot. - Q: Wasn’t the test unfair, as your local where inserting over the internet to SQL Azure? A: No, I was using a Stored Procedure, so the Insert was local to both SQL Azure and my local machine. - Q:

But how can your laptop be faster? A: In this case, I think it depends on a few factors: My local disc has write cache enabled, which is of course not recommended on production systems (reference: http://msdn.microsoft.com/en-us/library/ms186259.aspx) SQL Azure also have quite a lot more redundancy built in, than my laptop  Aside from the primary database, it also has 2 synchronous copies. This is excellent for Availability, but introduces overhead that impairs performance. Since you are guaranteed to have at least one of the copies outside the primary datacenter, I believe that that will be the main issue here. In addition, SQL Azure is a shared environment, and I have no control over what was running on the other databases running on the same hardware. Additionally , SQL Azure has built in throttling but that was most likely not invoked in this case. (Lots of good info is here: http://social.technet.microsoft.com/wiki/contents/articles/sql-azure-performance-and-elasticity-guide.aspx)

If you have any questions about anything in this article, feel free to contact me at Steinar<dot>Andersen<at>sqlservice<dot>se or via this page!

A SQL Azure tip a day (17) - Tuning your queries 1

I really miss a lot of DMV:s that I normally use for performance tuning, and I hope Microsoft will add some more support for DMV:s. When you build a database, you often need to compare the performance of two similar T-SQL statements or procedures to find the fastest statements and to get an honest result you need to flush the cache to compare them with "cold" cache. In SQL server 2008 you can use DBCC FREEPROCCACHE and DBCC DROPCLEANBUFFERS, but in SQL Azure these statements doesn't exist, and you can't flush the cache. On the other hand, you shouldn't use them in production anyway! But how should I compare them then? I don't have a SQL Azure development server and even if I had, I can't flush the cache to get a cold cache. You could of course develop on SQL server 2008 and hope that you only use supported T-SQL statements. Well, I guess thats not gonna happen. If you want to compare the two statements between each other in SQL Azure you can't rely on the execution time due to the hot cache. you need to look at the execution plan and the execution stats to find out which of them are using less IO operations and CPU worker time.

With the following script that I created for SQL server 2005, you can get the execution stats and the execution plans for individual SQL statements, but you can't get the procedure stats like in SQL 2008, becuase sys.dm_exec_procedure_stats is not supported in SQL Azure.

SELECT QS.sql_handle, ROW_NUMBER() OVER(PARTITION BY qs.sql_handle ORDER BY statement_start_offset) AS statement_no, qs.execution_count, qs.total_physical_reads, qs.total_logical_reads, qs.total_logical_writes, qs.last_execution_time, sql_total_worker_time_s=convert(money,qs.total_worker_time)/1000000, sql_max_worker_time_s=convert(money,qs.max_worker_time)/1000000, sql_last_worker_time_s=convert(money,qs.last_worker_time)/1000000, sql_min_worker_time_s=convert(money,qs.min_worker_time)/1000000, sql_avg_worker_time_s=(convert(money,qs.total_worker_time)/qs.execution_count)/1000000, sql_total_elapsed_time_s=convert(money,qs.total_elapsed_time)/1000000, sql_max_elapsed_time_s=convert(money,qs.max_elapsed_time)/1000000, sql_last_elapsed_time_s=convert(money,qs.last_elapsed_time)/1000000, sql_min_elapsed_time_s=convert(money,qs.min_elapsed_time)/1000000, sql_avg_time_s=(convert(money,qs.total_elapsed_time)/qs.execution_count)/1000000, SUBSTRING(ST.text, (QS.statement_start_offset/2) + 1, ((CASE statement_end_offset WHEN -1 THEN DATALENGTH(st.text) ELSE QS.statement_end_offset END - QS.statement_start_offset)/2) + 1) AS statement_text, qp.query_plan FROM sys.dm_exec_query_stats AS QS CROSS APPLY sys.dm_exec_sql_text(QS.sql_handle) as ST CROSS APPLY sys.dm_exec_query_plan(qs.plan_handle) AS qp

In the result you can find the queries that is using most CPU time (worker time), elapsed time, IO operations and the execution plan. If you are not used with reading the execution plans.

I'll recommend you to read : SQL Server 2008 Query Performance Tuning Distilled from Grant Fritchey. Read the next blog post from my collegue for some breaking news about insert performance in SQL Azure.

A SQL Azure tip a day (16) - what are you waiting for?

In SQL server 2008 you have a lot of DMV:s to use to tune your database, but SQL Azure is missing a lot of them, and it makes it a lot harder to tune your queries. One of the DMV:s I like a lot is sys.dm_os_wait_stats, but this DMV doesn't exist in SQL Azure (yet). Today I'll give you a small T-SQL script to show what you are waiting for right now. It is not a real substitute for the sys.dm_os_wait_stats, but you can at least see what you are waiting for right now. SELECT r.wait_type ,r.wait_time ,SUBSTRING(qt.text,r.statement_start_offset/2,( CASE WHEN r.statement_end_offset = -1 THEN LEN(CONVERT(NVARCHAR(MAX), qt.text)) * 2 ELSE r.statement_end_offset END -r.statement_start_offset)/2) AS query_text ,qt.dbid, dbname=DB_NAME(qt.dbid) ,qt.objectid ,r.sql_handle ,r.plan_handle FROM sys.dm_exec_requests r CROSS APPLY sys.dm_exec_sql_text(r.sql_handle) AS qt WHERE r.session_id > 50 AND WAIT_TYPE IS NOT NULL

If any query is wating for anything it will be returned and you can see what it's waiting for. The query returned may be a good candidate for tuning, but the root cause can be a completely different query.

Power Options ?

Som ni säkert känner till så har vi en tjänst Prestanda analys som vi säljer till fastpris. Bland mycket annat vi kontrollerar när vi utför den är Power Options på SQL Servern. Eftersom detta i de flesta fall är felinställt så skall jag här beskriva hur man märker det, vilken effekt det kan göra med rätt inställningar och vilken åtgärd man gör för att ändra detta. Ett enkelt sätt är se vilken inställning "Power Options" har att använda CPU-Z, som är helt gratis.

Som man kan se av de röda markeringarna i exemplet ovan så ser man att "Core speed" har "rated speed" på 2,66 GHz medan "actual speed" har ett värde på 1,99 GHz. Av detta kan man anta att Power Options har inställningen Balanced som är är en standardinställning på Windows Server 2008 och är den rekommenderade inställningen från Microsoft. Undersökningar och jämförelser av bl.a. Glen Berry visar dock att det blir en märkbar förbättring med High Performance istället och i synnerhet för OLTP-system som är väldigt CPU-beroende. Man kan få en förbättring på 15-22% av CPU prestandan till en kostnad av 6-11 % högre energiåtgång med "High Performance" jämfört med "Balanced". För "Power save" är skillnaden förstås ännu större. Om man vill ha så bra prestanda som möjligt på sin SQL Server miljö skall man allså alltid ändra till "High Performance". Detta kan man enkelt ändra genom att köra "Powercfg.cpl" eller mha kontrollpanelen.

Om man inte märker att detta slår igenom i CPU-Z som bilden nedan så måste man göra ändringar i BIOS och Power Management eller likande som innebär att detta sker.

A SQL Azure tip a day (15) - initial cost

A major benefit of SQL azure is the pricing model, you do not have an initial cost like when you buy your own SQL Server. Imagine you need a SQL server database with 99.9% availability and the cost for that server. You need at least two servers in a cluster, redundant power supply, redundant network/internet access, two storage arrays in the SAN with synchronous replication and they have to be located at different locations. That sounds cheap doesn't it? No? You are right! Also imagine that you need to handle heavy load once or twice a month, or why not once a year. You need to buy a server with enough resources to handle the peak load and if the peak is only once a year. What a waste of resources!

Well, you can always consolidate your database with other databases, but do you get enough resources when you really need them? It is not unusual that your database servers will cost $200 000 with SQL server licenses and SAN excluded. Well the SAN can be shared for all servers in your network, or can you? Yes you can, but do you get the performance you need? Your SAN technichians will ask you how many GB you need and not the number of IOPS you need, and that is two completely different things. On top of that you need a backup solution to handle your backups, or do you trust the SAN? Well, don't do it! I have seen two major outsourcing companies in Sweden relying on the SAN and it was an expensive experience for them, loosing a lot of money and reputation. To small companies or startups this can be heavy cost and big risk and to avoid this investment you can move in to SQL Azure, with no initial cost at all!

You only pay a monthly fee for what you really use. You can start with a small database and pay a small fee and grow as you need.

That is what I like with SQL Azure.

A SQL Azure tip a day (14) - Migration

If you plan to migrate a database to SQL Azure, you can find a tool at Codeplex to help you with the migration, SQL Azure Migration Wizard. There are some questions that has to be answered before you migrate a database to SQL Azure:

- Is your database compatible with SQL Azure?
- Does your database fit in the SQL Azure platform?
- Is your application suitable for Azure?
- Is your database designed to perform well?
- How should you handle the maintenance in SQL Azure?
- How are you going to test your application in the cloud to make sure it works?
- Should you migrate or design a new database?

If you can answer these questions, you can continue with the migration plans. And yes the questions may simple to answer, but if you have read my other blog posts about SQL Azure, you know that there are some things that you need to make sure you can handle, like:

- Max Database size
- Index fragmentation
- Connection termination due to heavy resource usage
- Etc.

Well, I would prefer to design a new database before trying to migrate a database to make sure the database is performing well. If you decide to continue with your migration, I'll guide you through the migration wizard.

1. Select Process In the first step you need to select what you want to do, in my case I want to Analyze and migrate a SQL database to make sure my database is compatible with SQL Azure. Select the option and click next.

2. Connect If you chose the "Analzye and Migrate" SQL Database, you need to connect to your server. Enter the name of your server, your login credentials and select master db or specify databasename.

3. Select Source If you selected the master db, you get a list of databases to choose from as source. Klick the desired database and click next.

4. Choose objects Next you need to choose the objects you want to migrate and in my case I choose to migrate "all objects" amd click next.

5. Script Wizard Summary In the next step you get a script summary and you get some early warnings if there are some objects that can't be migrated. In my case I have some encrypted procedures that can't be migrated, but that was expected. Click next to continue or exit to abort the process and fix any problems.

6. Result Summary If you clicked next, you can follow the process and see if there are some compatibility issues.

7. Result Summary You can also see the script that is created for your migration by clicking the "SQL scripts" tab.

8. Connect to Azure Once the script is created you need to connect to your SQL Azure database, enter your server name, login credentials and specify the datebase and click next.

9. Select Target In my case I selected the "Master DB" to get a list of all databases in my server and then I selected the database and clicked next to finish my migration. The wizard show you a confirmation dialog and if you want to continue you click the Yes button.

If everything worked fine it's now time to populate the database with data, point your application to the SQL Azure database and test your solution.

A SQL Azure tip a day (13) - Releases

The release cycle of SQL Azure is 4 times a year, and new functionality is added in every release. Some features from SQL server 2008 are still not implemented in SQL Azure, but some features are already released in SQL Azure and they will get released in SQL server 2012. Some of the new functions that are added in SQL Azure in the September 2011 release are not even documented anymore, like EOMONTH(), IIF(), TRY_PARSE(), etc. was added in the "What's new" section, but since the December release they are not documented. These features are added to SQL Server 2012 and you can read about them in books online or at: http://msdn.microsoft.com/en-us/library/cc645577(v=SQL.110).aspx I have added example of some of the new functions for you to try, and the rest of them I leave for you to try on your own. SELECT IIF(DATEPART(hh,GETDATE())>12,'AM','PM'); SELECT EOMONTH(GETDATE()) DECLARE @i CHAR(3)='A' SELECT TRY_PARSE( @i as int) SELECT CHOOSE(3, 'a','b','c','d') BEGIN TRY THROW 51000, 'The record does not exist.', 1; END TRY BEGIN CATCH PRINT ERROR_MESSAGE(); END CATCH

Stay tuned for more blog posts about SQL Azure, or contact any of our SQL server consultants if you want more information.

A SQL Azure tip a day (12) - KILL

If you have been working with any other SQL server edition before you most likely used the KILL statement to kill a slow running process or a process that are blocking other transactions. In SQL Azure there is no KILL statement and you can't kill the blocking connection, but on the other hand, SQL Azure will kill the processes that have been running for more than 5 minutes or is using to much resources.

I guess it's okey that it's handled by the platform, but in a high perfomance OLTP system 5 minutes is a long time to wait for a connection that is blocking lots of other processes. To avoid that problem you should make sure you optimize your code, split large data modifications in to smaller blocks and commit your transactions as soon as possible to avoid blockings in the first place. I guess you already heard that recommendation for T-SQL before, and as you can see, it's even more important in SQL Azure. Follow the guidelines described in http://windowsazurecat.com/2010/10/best-practices-for-handling-transient-conditions-in-sql-azure-client-applications/ to handle connections that may be terminated.

If you want to know whats currently executing in your SQL Azure database you can use a script like this one:

SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED; SELECT s.session_id, s.login_name, s.last_request_start_time, s.last_request_end_time, s.open_transaction_count, s.prev_error, r.start_time, r.status, COALESCE(object_name(st.objectid),'AdHoc'), st.text, r.cpu_time, r.reads, r.writes, r.logical_reads, r.granted_query_memory, r.row_count, r.wait_type, r.wait_time, r.last_wait_type, r.blocking_session_id, r.open_transaction_count, qt.query_plan FROM sys.dm_exec_sessions s INNER JOIN sys.dm_exec_requests r ON s.session_id = r.session_id LEFT JOIN sys.dm_tran_session_transactions t ON s.session_id=t.session_id CROSS APPLY sys.dm_exec_sql_text(r.sql_handle) st CROSS APPLY sys.dm_exec_query_plan(r.plan_handle) qt WHERE s.is_user_process=1

This will give you some execution statistics, the code that is executing, the query plan and some wait stats.

A SQL Azure tip a day (11) - The credit card constraint

This is the 11:th day I blog about SQL Azure, and it's the 11:th day I open more addresses on the Firewall, because of my mobile internet.

Iguess the database soon will open to anyone in the whole world! I can't wait until I get my fibre network! Once you sign up for the SQL Azure subscription, your credit card get charged for what you use. The charge will depend of number of databases, edition, size and outbound data transfer. If you want to keep track of the SQL Azure cost, there are two DMV:s you can use, sys.bandwidth_usage and sys.database_usage.

Since the service release in December there is a cost limit of $499.50 for every database larger than 40Gb, and you can use a script like this to keep track of your usage cost: DECLARE @priceWeb DECIMAL(4,2)=9.99; DECLARE @priceBusiness DECIMAL(4,2)=99.99; SELECT SKU, SUM(CASE WHEN U.SKU = 'Web' THEN (Quantity * @priceWeb/DAY(EOMONTH(U.TIME))) WHEN U.SKU = 'Business' THEN (CASE WHEN Quantity>40 THEN 40 ELSE Quantity END * @priceBusiness/DAY(EOMONTH(U.TIME))) END ) AS [TotalCost] FROM sys.Database_Usage AS u WHERE u.TIME >=DATEADD(D,0-DAY(GetUTCDate()),GetUTCDate()) AND u.TIME <=EOMONTH(GetUTCDate()) GROUP BY SKU; To get the cost for the data transfer you can use the following script: DECLARE @cost_per_mb DECIMAL (3,2)=0.15 DECLARE @mb INT = 1024*1024; SELECT u.Time_Period, u.Direction, @cost_per_mb * u.BandwidthInKB/@mb AS [TotalTransferCost] FROM ( SELECT Time_Period, Direction, SUM(Quantity) AS [BandwidthInKB] FROM sys.Bandwidth_Usage u WHERE u.TIME >=DATEADD(D,0-DAY(GetUTCDate()),GetUTCDate()) AND u.TIME <=EOMONTH(GetUTCDate()) AND class = 'External' AND u.Direction = 'Egress' GROUP BY Time_Period, Direction) AS u;

Well, as you already know, you pay for the size of your database, and you pay for the data transfer. To be cost efficient, you really need to design your database correct to avoid redundant data and you need to stop using SELECT *, or including more columns than you need. Otherwise you'll pay for an overhead that you actually can avoid. This is not a new recommendation, it has been there since the early year of relational databases, but the majority of all developers have ignored it since hardware got cheap. If your business is using a price model that is usage based you would gain a lot from using SQL Azure that is matching your pricing model.

Buggfixar ?

Som vi skrivit tidigare, så både hittar man och fixar buggar och andra förbättringar stadigt av SQL Server. Ibland är det störande saker som åtgärdas t.ex. att den grafiska exekveringsplanen inte alltid visas när man kört en fråga som returnerar en länk för exekveringsplanen. Detta har man kunnat komma runt genom att spara informationen i en fil, med ändelsen sqlplan och därefter öppnat den. En störande och onödigt moment som nu är fixat bland de senaste förbättringarna :-).

SQL Server 2008 R2 Service Pack 1 Cumulative Update 4

Som vanligt gäller det att alltid testa innan man gör förändringar i produktionsmiljön.

A SQL Azure tip a day (10) - Synchronize database

SQL Azure Data Sync (currently a CTP) is like replication in the cloud. It is easy to install and configure and you can use it to synchronize databases between a SQL server 2012 and SQL Azure, or between two SQL Azure databases. By using SQL Azure Data Sync, you can have an internal database application and publish some of your data to a cloud based application for external use or vice verse. Before you configure SQL Azure Data Sync, you need to create a user with permission to "logon as a service". It will be used by the local Data Sync agent. In this blog post, I will try to guide you through the setup and configuration.

1. Provision the Data Sync First of all you need to provision the Data Sync, by clicking the Provision Data Sync button, select your subscription and click next.

Select a region and click finish.

2. Create a Sync group Enter a name for your Sync group and press Enter to get to the next step. 3. Add a SQL server database to the sync group The second step is to add the SQL server database by click on the + sign in this dialog.

Next you need to add the database by selecting an existing sync member database or add a new database, and decide if it should be Bi directional, sync from the hub or sync to the hub. The SQL azure database is used as a hub.

4. Add New SQL Server database If you choose to add a new database you need to select an existing Client Sync Agent or install a new one. In this blog post, I'll assume you don't have a Client Sync Agent installed and

5. Install the agent.If you need to install a new agent, you need to:
- Download and install the agent
- Specify a name for your agent
- Generate and copy an agent key that you will use to register your local agent.

Before you click next, you should open your local Client Sync agent and register it with the key you copied. In the Client Sync Agent you click the Submit Agent Key, paste your copied key in the text box and click OK. Click the Register button and enter your servername, databasename and your login credentials.

Close the Client Sync Agent and switch back to the management portal, click next in the "Add Database to Sync Group" dialog. As you already done with Step 1, you can move on to Step 2 and click the Get Database List, select your database in Step 3 and click finish.

6. Add the SQL Azure database Now your SQL Server database is registered in the sync group and it's time to add the SQL Azure database. Enter or select the server and databasename, enter a valid SQL Azure login and password and click Add.

7. Configure the sync group Next step is to set the Sync Schedule and the conflict resolution. Enter a Sync Schedule between 5 minutes and 1 Month and decide who the winner in a conflict should be.

8. Select the data to be synchronized In the last dialog you can choose the tables and the columns to use in your data sync, and for every table, you can add a row filter to get only the data that meets your criteria.

9. Deploy the Data Sync Now you are almost done, just click the Deploy button at the top of the SQL Azure Management Portal, and once the Data Sync is deployed it should look like something like this. Once you have configured this, you can add more databases to the sync group.