Maybe I will like Facebook after all

Check SQL Treeo on Facebook.

They provide access to previous row (LAG) or subsequent row (LEAD)  in result set or partition. If they are combined with PARTITION BY clause within required OVER clause, it accesses previous/next row only from given partition. If there is previous/next row in result set/partition, both function returns null. These functions basically replace necessity for self-joins when you need to access previous/next row. Both functions provides access to rows based on given offset relative to current row.

FIRST_VALUE and LAST_VALUE functions

These functions are very similar to LAG and LEAD and do what is expected – provide access to first or last row in result set or partition. They must be combined with OVER clause as well, PARTITION BY clause is optional.

Here is very simple example of new analytical functions in action. SQL command groups employees’ lastname by department and use LAG, LEAD and FIRST_VALUE function results.

 SELECT 

 d.GroupName,
 b.LastName,
 LAG (LastName) OVER (PARTITION BY d.GroupName ORDER BY b.LastName) AS 'LAG - prev. value',
 LEAD (LastName) OVER (PARTITION BY d.GroupName ORDER BY b.LastName) AS 'LEAD - next. value',
 FIRST_VALUE (LastName) OVER (PARTITION BY d.GroupName ORDER BY b.LastName) AS 'FIRST_VALUE'

 FROM HumanResources.Employee e
    JOIN Person.Person b ON b.BusinessEntityID = e.BusinessEntityID
    JOIN HumanResources.EmployeeDepartmentHistory dh ON dh.BusinessEntityID = b.BusinessEntityID
    JOIN HumanResources.Department d ON d.DepartmentID = dh.DepartmentID
    ORDER BY d.GroupName, b.LastName

CUME_DIST, PERCENTILE_CONT, PERCENTILE_DISC and PERCENT_RANK

These function are pure statistical. You can use it when you need to calculate cumulative distribution or various types of percentile.

• sys.dm_exec_describe_first_result – this procedure returns column of first result set in query. Query is passed to procedure as a dynamic SQL.
• sys.dm_exec_describe_first_result_set_for_object – do the same thing as previous but for specific object_id
• sp_describe_undeclared_parameters – this procedure pulls parameters from SQL query and return them in result set

See following example for sys.dm_exec_describe_first_result:

DECLARE @sql VARCHAR(500)

SET @sql = 
'USE AdventureWorks
SELECT e.LoginID, c.FirstName, c.LastName FROM HumanResources.Employee e 
JOIN Person.Contact c ON c.ContactID = e.ContactID'

SELECT * FROM sys.dm_exec_describe_first_result_set (@sql, null, 0) ;

…will result in grid with LoginID, FirstName and LastName columns and their metadata:

Here is sample for sp_describe_undeclared_parameters:

DECLARE @sql NVARCHAR(MAX)

SET @sql = 
'USE AdventureWorks
SELECT e.LoginID, c.FirstName, c.LastName FROM HumanResources.Employee e 
JOIN Person.Contact c ON c.ContactID = e.ContactID
WHERE FirstName LIKE @firstName'

EXEC sp_describe_undeclared_parameters @tsql= @sql

…will result in grid describing @firstName parameter:

Those procedures might be very handy when you’re dealing with dynamic SQL but there are a lot of limitations. Please read Books Online for more details.

DECLARE @variable VARCHAR(50) = 'I am not NULL'    

SELECT 

    CASE 
        WHEN @variable IS NOT NULL THEN 'NOT_NULL'
        ELSE NULL
    END

But in SQL Server 2011 you can use true IIF function:

DECLARE @variable VARCHAR(50) = 'I am not NULL'    

SELECT IIF (@variable IS NOT NULL,'NOT_NULL',NULL)    

CHOOSE Function
CHOOSE function is not so typical but may help as well. Purpose of this function is to pick a value based on its index from given range.

Check this sample with subconscious communication :

SELECT CHOOSE ( 3, 'You', 'love', 'SQLTreeo')

Result will be “SQLTreeo”.

Nice.

Here is important settings from standard cursor declaration syntax:

DECLARE cursor_name CURSOR
[ LOCAL | GLOBAL ]
[ FORWARD_ONLY | SCROLL ]
[ STATIC | KEYSET | DYNAMIC | FAST_FORWARD ]
[ READ_ONLY | SCROLL_LOCKS | OPTIMISTIC ]

Here is fast human description of cursor options:

[ LOCAL | GLOBAL ] – Use LOCAL, cursor will live only in scope of batch. GLOBAL cursor lives in whole connection, I can’t imagine many scenarios where you really need it.

[ FORWARD_ONLY | SCROLL ] – Use FORWARD_ONLY, cursor will enable only sequential forward only reading. SCROLL cursor enables to move freely forward and backward which require more resources.

[ STATIC | KEYSET | DYNAMIC | FAST_FORWARD ] – Use FAST_FORWARD, it is the combination of READ_ONLY and FORWARD_ONLY cursor. FAST_FORWARD cursor enables only forward and read only movement which makes it most efficient compared to the other types. STATIC cursor loops over copy of data, not over original data hence doesn’t support any updates. Creating copy of data is very resource-intensive. KEYSET cursor requires unique key identifying rows, these keys are copied in tempdb when cursor is opened. It loops then based on those keys. You must have very good reason to use KEYSET cursor. DYNAMIC cursor immediately reflects any changes made to underlying tables.

[ READ_ONLY | SCROLL_LOCKS | OPTIMISTIC ] -READ_ONLY is good but doesn’t support any updates. SCROLL_LOCKS option tells cursor to lock every read row to ensure that updates through cursor will succeed.

And few more important points :

• start with LOCAL FAST_FORWARD cursor and then change it if you need something special
• use minimal count of rows and columns within cursor
• think about what you’re doing inside cursor, try to avoid complex SELECT queries inside
• try to avoid STATIC and KEYSET cursors, they work with tempdb which is another overhead
• don’t forget to CLOSE and DEALLOCATE cursor regardless of its scope settings

1. SQL Azure is cloud version of SQL Server database engine.
2. Microsoft has many computers spread over three continents (Europe, Asia, North America). SQL Azure is running on many of them
3. As customer, you can create virtual SQL server on these cloud servers. Virtual server consists of databases, user accounts etc. known stuff
4. You can create databases on virtual server. You must pay for them on regular basis, appx 10 USD for GB per month
5. There are two editions – Web (1 and 5GB sizes) and Business (10,20,30,40 and 50 GB sizes).
6. If you need bigger databases you can use sharding.
7. You have no control where your databases are physically placed (on which boxes)
8. When you’re creating database you chose edition (Web/Business) and maximal size of database (1 or 5 GB for Web and 10 or 20 or 30 or 40 or 50 for Business)
9. You pay monthly but only for space which you’ve consumed rounded up to next available size in your edition. Example: You have Web edition with 1GB and consumed 0,2 GB – you pay for 1 GB which is 10 USD/month. Example 2: You have Business edition with 40 GB and consumed only 16 GB – you pay as for 20 GB which is 200 USD.
10. “Consumed space” is tables, indexes etc. – everyhing which is stored in .MDF file. Transaction log space is for free.
11. There are no fees for HW, CALs, processor licences etc. There is one fee you may pay – for transferred GB’s. It is 0,1 USD/GB for in-traffic and 0,15 USD for out-traffic. However this fee is relevant only if your application layer is out of cloud. If you have your application layer within cloud, there is no external traffic in/out SQL Azure which means no additional fees.
12. Microsoft states that for this money you get high availability SQL Server and automatic, seamless fail-over if anything goes wrong
13. You are basically focused only to your databases, not to HW, operating system, security updates or anything else

Next time, I will continue with what is permitted and what’s not from administration point of view.

On my current project, we started to use SQL Prompt SSMS add-in many months ago but I discovered it’s great value for T-SQL refactoring yesterday. It provides feature which is invaluable for described refactoring scenarios. This features is called “Smart Rename” and provides consistent renaming of SQL object even with renaming it in all dependencies.

Saved me hours this week.

• Clustered index is present on table
• Clustered index not present on table, records are “organized” in heap. Other non-clustered indexes doesn’t affect heap, they only point to records in the heap.

For both situations SQL Server knows how many records are contained either in the clustered index or in the heap. This information is held in sys.indexes system table and maintained by updating statistics. This is the reason why number of rows in sys.indexes table is not guaranteed – if statistics are not updated by any reason, this number is not actual.

Here’s code:

USE AdventureWorks

DECLARE @table VARCHAR(250)
SET @table = 'Person.Address' -- name of your table
    
SELECT rowcnt
FROM sys.sysindexes
WHERE id = OBJECT_ID(@table) 
      AND (indid = 0 OR indid = 1) -- clustered index or heap

I am personally switched off standard intellisense in SSMS 2008 long time ago and using Red Gate’s SQL Prompt instead because it is just better. This is much more than enhanced intellisense but probably to align SQL Prompt intellisense to SSMS 2008 intellisense behavior, partial name matching is not implemented in SQL Prompt . I was googling and found out that partial name matching is in top 3 feature request for SQL Prompt. I voted

To complete intellisense story – I was googling for full list of SSMS 2011 intellisense enhancements and found this article.

It seems to me that CDC is similar to same feature on Oracle – it is asynchronous tracking of changes to user tables by harvesting transaction log changes and translating them user readable relational format. Change tracking does similar thing but is synchronous and provides you less information about changes to tables. It provides only information that table was changed but doesn’t provide row values for changes which were made. CDC is treated in SQL Server documentation as more robust feature than Change Tracking. Maybe this is the reason why CDC is supported only in Enteprise and Datacenter edition while Change Tracking is supported in all versions. CDC is also mentioned together with ETL process where it has probably most useful usage.

This was very basic description of difference between CDC and Change Tracking. Let’s look closer to CDC now.

I borrow following schema from MSDN, please read this paragraph to end before looking to schema.  As I mentioned above, CDC provides asynchronous tracking of changes by looking to transaction Log and translating recorded changes for Source tables. Changes are gathered by special SQL Server Agent Job (Capture process on following picture). These changes are inserted to Change tables which can be accessed by special user-defined functions created for that purpose  – they are called Change data capture query functions on following picture. Schema depicts situation when ETL process consumes these functions but this is only sample usage.

How to setup Change Data Tracking (CDC)

Setup is quite straightforward (more than querying changes). Here are steps to bring it alive:

1. Enable CDC for database by calling sys.sp_cdc_enable_db procedure. It adds few CDC related system tables to current database and set IS_CDC_ENABLED column in sys.databases to 1.
2. Enable CDC for particular table by calling sys.sp_cdc_enable_table. It creates SQL Server Agent Job for harvesting transaction log, Change tables and Change data capture query functions which enable you to query Change tables. It does few more things like creating “cdc” security schema in your database.
3. Now any changes for enabled table are gathered by job and written to change tables.

How to query changes

Query changes is not as straightforward as is for Change Tracking feature. It basically let you deal with LSN (Log Sequence Number) directly. LSN is unique identifier for each record in transaction log.

It is recommended to use only Change data capture functions for querying changes – not Change tables directly. These functions are created dynamically for each CDC-enabled table (created in setup – step 2.). Let’s Assume that we have table called “Customer” in “dbo” schema. There are than two basic function to retrieve changes for that table:

• cdc.fn_cdc_get_all_changes_dbo_Customer. This table-valued function returns ALL changes to the Customer table, including previous and new values (depends on parameters). It takes range of LSN you want to search changes for and @row_filter parameter. You can pull LSN range from built-in functions sys .fn_cdc_get_min_lsn and sys .fn_cdc_get_max_lsn (see T-SQL below). Row filter parameter can have two values – “all” which returns all changes but for changes caused by UPDATEs it doesn’t include previous values, only new ones. “all update old” parameter value returns the same as “all” but for UPDATEs returns previous values as well.
• cdc .fn_cdc_get_net_changes_dbo_Customer. This table-valued function returns only takes three parameters as well but returns only final changes to each row. This function is created only if @supports_net_changes parameter is set to 1 while enabling CDC for table. I will not concentrate to this function, please refere to MSDN if you should need it.

See this short sample how to setup up CDC and query changed data:

-- create Customer table in current DB
CREATE TABLE Customer (ID INT IDENTITY (1,1) PRIMARY KEY, Name VARCHAR(50))

-- Enable CDC for current DB
EXEC sys.sp_cdc_enable_db

-- Enable CDC for Customer table
EXEC sys.sp_cdc_enable_table @source_schema = 'dbo', @source_name = 'Customer', @role_name='test', @supports_net_changes = 1

-- insert some records
INSERT INTO Customer (Name) VALUES ('Microsoft')
INSERT INTO Customer (Name) VALUES ('Oracle')
INSERT INTO Customer (Name) VALUES ('Apple')

!!! -- now SQL Server agent job named cdc.<database_name>_capture must be executed

-- get min LSN for table customer
DECLARE @min_lsn BINARY(10) = sys.fn_cdc_get_min_lsn ('dbo_Customer')
-- get max LSN for current DB
DECLARE @max_lsn BINARY(10) = sys.fn_cdc_get_max_lsn ()

-- select all changes made to Customer table
SELECT * FROM cdc.fn_cdc_get_all_changes_dbo_Customer(@min_lsn, @max_lsn, 'all update old');

Result is following:

Not nice result, isn’t it? Result contains all columns from Customer table (ID and Name) and some more. _$operation column contains indication of INSERT (2), DELETE (1) or UPDATE with previous values (3), UPDATE for new values (4). _$update_mask is bit mask containing information which column was updated (if applicable). Please see full description here.

As you see, you must handle LSN directly. To track changed data in increments (probably most common scenario) you would have to store last max LSN value you’ve processed changes for and start another run with this value.

There are couple of helper fuctions which may help you with LSN:

• sys.fn_cdc_map_time_to_lsn – it map time milestones to LSN
• sys.fn_cdc_map_lsn_to_time – … do opposite
• sys .fn_cdc_increment_lsn – returns next LSN based upon your “stored” LSN. Great for tracking incremental changes.

That was basics of Change Data Capture (CDC). There’s really much much much more about it – if you’re seriously considering using this feature, read full description of CDC in MSDN.

Thanks!

    -- create sample parent-child tables
    CREATE TABLE ParentTable (Id INT IDENTITY, Version INT, TempId INT)
    CREATE TABLE ChildTable (Id INT IDENTITY, ParentId INT, Name VARCHAR(100)) -- here is version column redundant just for this sample1

    -- insert sample data
    INSERT INTO ParentTable (Version) VALUES (1)
    INSERT INTO ParentTable (Version) VALUES (1)
    INSERT INTO ParentTable (Version) VALUES (1)
    INSERT INTO ParentTable (Version) VALUES (1)
    INSERT INTO ChildTable (ParentId, Name) VALUES (1,'I am 1st child record of parent no. 1')
    INSERT INTO ChildTable (ParentId, Name) VALUES (1,'I am 2nd child record of parent no. 1')
    INSERT INTO ChildTable (ParentId, Name) VALUES (2,'I am 1nd child record of parent no. 2')
    INSERT INTO ChildTable (ParentId, Name) VALUES (2,'I am 2nd child record of parent no. 2')
    INSERT INTO ChildTable (ParentId, Name) VALUES (3,'I am 1st child record of parent no. 3')
    INSERT INTO ChildTable (ParentId, Name) VALUES (3,'I am 2nd child record of parent no. 3')
    INSERT INTO ChildTable (ParentId, Name) VALUES (4,'I am 1st child record of parent no. 4')
    INSERT INTO ChildTable (ParentId, Name) VALUES (4,'I am 2nd child record of parent no. 4')

    -- display sample data as join between Parent and Child table
    SELECT p.Id ParentId, p.Version ParentVersion, p.TempId as VersionToParentId, c.Id ChildId, c.Name as ChildName 
        FROM ParentTable p
        JOIN ChildTable c ON c.ParentId = p.Id

    -- here starts copy sql    
    DECLARE @ParentsToCopy TABLE (Id INT)
    DECLARE @ParentsMapping TABLE (OldId INT, ClonedId INT)    -- temp table holding pairs of old and new ids of parent entities

    -- parent Ids to copy
    INSERT INTO @ParentsToCopy VALUES (1),(2),(3),(4)

    -- Copy parents at first and save pairs of OldId and ClonedId
    INSERT INTO ParentTable (Version, TempId)
        OUTPUT inserted.TempId, inserted.Id
        INTO @ParentsMapping (OldId, ClonedId)        
        SELECT Version+1, p.Id
            FROM ParentTable p
            JOIN @ParentsToCopy pc ON pc.Id = p.Id -- filter parent records to those I want to copy

    --now have in @ParentsMapping pairs of old and new id  of ParentTable entity        

    --let's insert child records by joining them to @ParentsMapping.OldId
    -- It finds children records which parents I've copied in previous step and use ClonedId as new ParentId for them
    INSERT INTO ChildTable (ParentId, Name)
        SELECT p.ClonedId, Name
            FROM ChildTable c
            JOIN @ParentsMapping p ON p.OldId = c.ParentId  

    -- display sample data again 
    SELECT p.Id ParentId, p.Version ParentVersion, p.TempId as VersionToParentId,c.Id ChildId,  c.Name as ChildName 
        FROM ParentTable p
        JOIN ChildTable c ON c.ParentId = p.Id

 
Main point of this script is that you get newly inserted IDs of parent records in @ParentsMapping table and than can use it as source for children records copy operation. But it is not possible without TempId column in ParentTable added only for copy purposes. Reason why you have to add TempId column to parent entity is in limitation of OUTPUT clause. You cannot use anything but only “inserted.*” columns or constants with OUTPUT clause. You cannot simply do this:

    INSERT INTO <some_table> (some_columns)
        OUTPUT inserted.*, ID_OF_PARENT_RECORD
        INTO <temp_table>
        SELECT ID_OF_PARENT_RECORD
            FROM <another_table>

You have to insert ID_OF_PARENT_RECORD column to ParentTable.TempId column and get it back to @ParentsMapping using “inserted.TempId”. That’s thing I really don’t like.
If you have better idea how to copy parent-child record (but as bulk operation not row by row) without altering parent entity, please let me know.

SELECT * FROM <table_name>  TABLESAMPLE (10 PERCENT)

… this will return approximately 10% procent of rows from <table_name>.

It’s quite ellegant solution for SELECTing news or random records from table for any purpose. How resulting data are randomized in the background? SQL Server sort of randomly picks physical data page and return everything on the page. This means that it is not guaranteed that TABLESAMPLE returns always same number of rows. From table which has 100 000 records, TABLESAMPLE (10 PERCENT) may return 9943 records for the first call and 10 232 for second call. This is because combination of two facts: TABLESAMPLE picks whole content of randomly chosen data page and each data page can carry different number of rows. This behavior might suits you or not. You choose.

You can also combine TABLESAMPLE with TOP clause:

SELECT TOP 10 * FROM <table_name> TABLESAMPLE (10 PERCENT)

… but in that case, this solution for selecting exact count of random records is better:

SELECT TOP 10 * FROM <table_name> ORDER BY NEWID() 

It has one “but” – you must use TABLESAMPLE only with tables, not views or table UDF. It make sense, it just comes from its internal working.

One more thing. You can use table sample also like this:

SELECT * FROM <table_name>  TABLESAMPLE (1000 ROWS)

It returns “approximately” 1000 rows from <table_name>. But anyway, ROWS clause is internally converted to percentage of rows based on available statistics.

Unfortunately you must treat these kind of parameters as readonly (with READONLY clause), so you cannot pass table variable in stored procedure and update it there.

Life will be much easier if you could do this (this code is obviously only schematic):

--------------------------------------------
-- create Stock table type
--------------------------------------------
CREATE TYPE Stock AS TABLE 
(
    -- many important columns
    Value VARCHAR(500)    
)
GO

--------------------------------------------
-- create stored proc which does some complex calculations over list of stocks
--------------------------------------------
CREATE PROC ap_Do_Some_Very_Complex_Calculation_Over_Stocks
    @stocks Stock  -- here should be READONLY clause
AS
BEGIN
        
    UPDATE @stocks
        SET Value = 'complex calculation'
        
    -- @stocks variable leaves this procedure changed
END

--------------------------------------------
-- do calculations over list of stocks
--------------------------------------------
DECLARE @stocks AS Stock 

INSERT INTO @stocks
    SELECT * FROM -- fill @stocks table from somewhere
    
EXEC ap_Do_Some_Very_Complex_Calculation_Over_Stocks @stocks

-- here @stocks table content would be changed by procedure

I was eager to try it in SQL Server 2011 “Denali” but was dissappointed because there was no improvement of this feature (still hoping that “yet”).
Here is proof, you are still required to make table value type readonly while used as SP parameter in SQL Server 2011 “Denali”:

Martin Catherall commented my previous post and advised me to raise connect item if not exists yet. Connect item for this issue already exists for quite long time but with promising comment from Microsoft that it may be implemented in version 2011. Let’s hope.

In case this features will not be introduced in SQL Server 2011, you can use “workaround” with XML datatype variable as input parameter to stored procedure. This approach is described with connect item I’ve referred to. But If you are focused at least a little to performance, I wouldn’t recommend it. XML handling has always performance drawbacks and cannot replace table value type especially if you update it within stored procedure. You can also read excellent article on this theme here – Why Read-only Table Parameters is Not Enough.

I was googling and googling but found only not suitable solutions or solutions which I don’t like. That’s why I am now sharing solution which I find quite ellegant. Feel free to comment it or propose anything better. Thanks

-- create UDTT which serves as input parameter
CREATE TYPE Interval AS TABLE (datefrom DATETIME, dateto DATETIME)

-- create UDF which combines date intervals
CREATE FUNCTION fn_MergeIntervals (@intervals Interval READONLY)
RETURNS @output TABLE (datefrom DATETIME, dateto DATETIME)
AS 
BEGIN

    -- create unique milestones consisting of datefrom and dateto of each interval
    WITH milestones (milestoneOrder, milestone, milestoneType)
    AS
    (
        SELECT 
                    
            ROW_NUMBER() OVER (ORDER BY milestone) milestoneOrder,  -- create order for each milestone
            milestone,
            milestoneType
            
        FROM (SELECT datefrom as milestone, 1 AS milestoneType FROM @intervals
              UNION
              SELECT dateto, 2 FROM @intervals) AS ms      
    )
    
    -- join milestone to previous milestone based on ROW_NUMBER orderring
    INSERT INTO @output
        SELECT 
                
            CASE 
                WHEN m.milestoneType = 2 THEN DATEADD(dd, 1, m.milestone) -- distinguish between starting and ending date
                ELSE m.milestone
            END    datefrom ,    
            CASE 
                WHEN s.milestoneType = 1 THEN DATEADD(dd, -1, s.milestone) -- distinguish between starting and ending date 
                ELSE s.milestone
            END    dateto 

        FROM milestones m
        JOIN milestones s ON s.milestoneOrder = m.milestoneOrder + 1
    
    RETURN
END

-- fill intervals from sample 
DECLARE @intervals AS Interval

INSERT INTO @intervals VALUES ('20110101','20110430');
INSERT INTO @intervals VALUES ('20110420','20111005');
INSERT INTO @intervals VALUES ('20110415','20111130');

-- merge intervals    
SELECT * FROM fn_MergeIntervals (@intervals)

Result is following:

var command = commands.AddNamedCommand2(
                    (AddIn)addInInst,
                    "ShowSQLTreeoSettings",
                    "SQL Treeo",
                    "Displays the SQL Treeo Settings Dialog",
                    false,
                    101,
                    ref contextGuids)

Where 5th is information to get icon from own resource and 6th parameter is identifier of the icon resource. Whole Google and Interet is almost silence about that, it took couple of hours

Anyway, here is “list” of features which should work now:

• Create custom folders in SSMS’s object explorer using drag&drop. It works for databases, stored procedures, functions, views and tables
• Ctrl+click on object will bring ALTER script (my favourite)
• Perform bulk operations in explorer-style management dialog – I did that because I while I was refactoring and re-foldering more objects, drag&drop was not enough

If you’re interested in more features you can let me know here.
Please bear with me, it will be available soon.
 
PS: I found out that I wasn’t receiving any emails from contact form during last week, if you registered for notification of release, I probably didn’t get your email.




Jakub Dvorak @ www.sqltreeo.com

BEGIN TRY
   
    -- plenty of code or function/procedures invocation 
    -- where you don't have any error handling 

    -- will it work?
    SELECT 1/0
    
END TRY
BEGIN CATCH

    DECLARE @errorid INT = ERROR_NUMBER()
    DECLARE @proc VARCHAR(200) = ERROR_PROCEDURE()
    DECLARE @ErrorMessage VARCHAR(200) = ERROR_MESSAGE()
    DECLARE @Severity INT = ERROR_SEVERITY()
    DECLARE @State INT = ERROR_STATE()
    
    SET @ErrorMessage = 'My error - ' + @ErrorMessage
    RAISERROR(@ErrorMessage, @Severity, @State) 

END CATCH

In SQL Server 2011 you can simply use THROW keyword:

BEGIN TRY
    
    -- plenty of code or function/procedures invocation 
    -- where you don't have any error handling 

    -- will it work?
    SELECT 1/0
    
END TRY
BEGIN CATCH

    THROW

END CATCH

I like that but question is who will re-write my existing code




Jakub Dvorak @ www.sqltreeo.com

Very sad, I am still doomed to nasty workarounds such as “ERROR” string returning or on-purpose division by zero.
Hopefully it will be in final version.




Jakub Dvorak @ www.sqltreeo.com

I used this tool to create RAM disk. It’s commercial but more stable than some free alternatives (I am using it also Visual Studio development).

This code performs simple 100k insert, I ran it on database stored on SSD disk at first, than on database stored on RAM disk (see results below):

-- create database on physical drive c:\ with default setting
CREATE DATABASE [TestPerformance] ON  PRIMARY 
( NAME = N'TestPerformance', FILENAME = N'C:\Sql Databases\TestPerformance.mdf' , SIZE = 4352KB , MAXSIZE = UNLIMITED, FILEGROWTH = 1024KB )
 LOG ON 
( NAME = N'TestPerformance_log', FILENAME = N'C:\Sql Databases\TestPerformance_log.LDF' , SIZE = 576KB , MAXSIZE = 2048GB , FILEGROWTH = 10%)
GO
-- create database on ramdisk (drive L:\) with default setting
CREATE DATABASE [TestPerformanceRamdisk] ON  PRIMARY 
( NAME = N'TestPerformanceRamdisk', FILENAME = N'L:\TestPerformanceRamdisk.mdf' , SIZE = 4096KB , MAXSIZE = UNLIMITED, FILEGROWTH = 1024KB )
 LOG ON 
( NAME = N'TestPerformanceRamdisk_log', FILENAME = N'L:\TestPerformanceRamdisk_log.ldf' , SIZE = 1024KB , MAXSIZE = 2048GB , FILEGROWTH = 10%)
GO

-- create simple test tables in both databases
CREATE TABLE TestPerformance..TestInsert (testColumn UNIQUEIDENTIFIER)
GO
CREATE TABLE TestPerformanceRamDisk..TestInsert (testColumn UNIQUEIDENTIFIER)
GO

-- run this script on both databases and compare time
DECLARE @i INT = 100000
DECLARE @start DATETIME = GETDATE()
DECLARE @end DATETIME 

WHILE @i > 0
BEGIN

    INSERT INTO TestInsert
        VALUES (NEWID())

    SET @i -= 1
END

SET @end = GETDATE()
SELECT CONVERT (TIME, @end - @start)

Results are nice.
For SSD version, it was (~20s):

… for RAM disk version, it was (~7s):

RAM disk version is ~300% faster which is not negligible. Using RAM disk needn’t to be an option only for development machines. You can use RAM disk even for production to hold TEMPDB database (or any other treated as non-critical for persistence). Tony Rogerson’s wrote about this here.




Jakub Dvorak @ www.sqltreeo.com

USE master
GO
ALTER DATABASE <your_db> SET OFFLINE WITH ROLLBACK IMMEDIATE
GO
ALTER DATABASE <your_db> SET ONLINE WITH ROLLBACK IMMEDIATE
GO
DROP DATABASE  <your_db>
GO
CREATE DATABASE <your_db>

Jakub Dvorak @ www.sqltreeo.com

INSERT INTO Continents (Name) VALUES ('Asia')
INSERT INTO Continents (Name) VALUES ('Africa')

With Table Value Constructors you can do this:

INSERT INTO Continents (Name)
VALUES ('Asia'),('Africa')

I must admin that I like it but there’s more. Sometimes you need list of constants in temporary set to be used just within your batch – I was always doing something similar to this (if there was only few values):

SELECT 'Africa' 
UNION ALL 
SELECT 'Asia'

With Table Value Constructors you can do this:

SELECT * 
    FROM (VALUES ('Asia'), ('Africa')) AS Continents (Name)

You can even use subquery within VALUES command. Check full reference and limitations of Table Value Constructors on Technet.

Jakub Dvorak @ www.sqltreeo.com

    -- inserting records via vw_Customer which has instead of trigger on itself. 
    -- Underlying Customer table has Id column defined as IDENTITY.
    INSERT INTO vw_Customer ( Name , Value_FilledBy_Instead_Of_Trigger )
        OUTPUT inserted.Id, inserted.Name, inserted.Value_FilledBy_Instead_Of_Trigger
        INTO @someTable
        SELECT Name, Value
            FROM someOtherTable

Result is that you don’t have identity values in output @someTable. This is behavior described e.g. here or discussed on Microsoft Connect here.

I used workaround with process-keyed table and process-keyed view which encapsulates reading/inserting of keyed records. It is similar workaround as using #table but I dislike #table management within triggers.

Check this commented code:

/*
-- drops 
DROP TABLE Customer 
DROP VIEW vw_Customer
DROP TABLE PK_Customer_TriggerScope
DROP VIEW vw_Customer_TriggerScope
*/

-- create customer table
CREATE TABLE Customer (id INT IDENTITY (1,1) NOT NULL, Name VARCHAR(20) NOT NULL, Value_FilledBy_Instead_Of_Trigger VARCHAR(20) NOT NULL)
GO

-- create customer view
CREATE VIEW vw_Customer
AS
SELECT * FROM Customer
GO

-- create process keyed table for usage in instead of trigger
CREATE TABLE PK_Customer_TriggerScope ( SPID INT, Id INT, Name VARCHAR(20), Value_FilledBy_Instead_Of_Trigger VARCHAR(20) )
GO

-- add default constraint for process keyed table to ensure that SPID is filled/filtered automatically
ALTER TABLE PK_Customer_TriggerScope ADD  CONSTRAINT DF_PK_Customer_TriggerScope_SPID  DEFAULT (@@spid) FOR [SPID]
GO

-- create view on process keyed table to encapsulate records process keying 
CREATE VIEW vw_Customer_TriggerScope
AS 
SELECT * FROM PK_Customer_TriggerScope WHERE SPID = @@SPID
GO

-- create instead of insert trigger on customer view
CREATE TRIGGER tg_IOI_vw_Customer ON vw_Customer INSTEAD OF INSERT
AS
BEGIN

    -- flush records keyed for this process 
    DELETE FROM vw_Customer_TriggerScope
    
    -- do customer inserts and fill PK_Customer_TriggerScope with output keyed for this process
    -- unfortunately you cannot use view in output clause so PK_Customer_TriggerScope must be use directly
    INSERT INTO Customer ( Name , Value_FilledBy_Instead_Of_Trigger )
        OUTPUT @@SPID, inserted.Id, inserted.Name, inserted.Value_FilledBy_Instead_Of_Trigger
        INTO PK_Customer_TriggerScope 
        SELECT Name, 'Filled by IOI'
            FROM inserted

END
GO

-- Insert few customers and try to get identity 
INSERT INTO vw_Customer ( Name )
    SELECT TOP 10 name FROM msdb.sys.objects -- use sys.objects as list of customers

-- get inserted records from process keyed table 
-- it is ensured that now it contains only customer records inserted within instead of trigger
SELECT * FROM vw_Customer_TriggerScope

Jakub Dvorak @ www.sqltreeo.com

I wrote helper stored procedures which take UDTT name as only parameter and returns DROP and CREATE scripts of all references. It basically do what I’ve mentioned, it scripts all UDTT’s references and saves my time.

First is ap_FindReferences which finds all references and returns them as single result set. It would be enough to display this result set as text in SSMS (CTRL+T) but it’s not because SSMS cannot display strings long more than few thousands characters in results pane. That’s why there is second procedure ap_WriteReferences which do quite nasty job of writing result from ap_FindReferences into .sql file you can display in SSMS.

Usage is following:

EXEC ap_WriteReferences '<your user-defined table type>'

…result is text file defined within ap_WriteReferences with scripted references to your UDDT.

Good option is to bind this command to keyboard shortcut in SSMS.

Here are those two procedures (some notes follow):

-- Find all referencing objects to user-defined table type in @fullObjectName parameter
-- and generate DROP scripts and CREATE scripts for them
CREATE PROC ap_FindReferences (@fullObjectName VARCHAR(200))
AS
BEGIN
    SET NOCOUNT ON

    IF (TYPE_ID (@fullObjectName) IS NULL)
    BEGIN
        RAISERROR ('User-defined table type ''%s'' does not exists. Include full object name with schema.', 16,1, @fullObjectName)
        RETURN
    END;

    WITH sources
    AS
    (
        SELECT ROW_NUMBER() OVER (ORDER BY OBJECT_NAME(m.object_id)) RowId, definition
        FROM sys.sql_expression_dependencies d
        JOIN sys.sql_modules m ON m.object_id = d.referencing_id
        JOIN sys.objects o ON o.object_id = m.object_id
        WHERE referenced_id = TYPE_ID(@fullObjectName)
    )

    SELECT 

        'DROP ' +
            CASE OBJECTPROPERTY(referencing_id, 'IsProcedure')
            WHEN 1 THEN 'PROC '
            ELSE
                CASE
                    WHEN OBJECTPROPERTY(referencing_id, 'IsScalarFunction') = 1 OR OBJECTPROPERTY(referencing_id, 'IsTableFunction') = 1 OR OBJECTPROPERTY(referencing_id, 'IsInlineFunction') = 1 THEN 'FUNCTION '
                    ELSE ''
                END
            END
        + SCHEMA_NAME(o.schema_id) + '.' +
        + OBJECT_NAME(m.object_id)    

    FROM sys.sql_expression_dependencies d
    JOIN sys.sql_modules m ON m.object_id = d.referencing_id
    JOIN sys.objects o ON o.object_id = m.object_id
    WHERE referenced_id = TYPE_ID(@fullObjectName)
    UNION  ALL
    SELECT  'GO'
    UNION  ALL
    SELECT
        CASE
            WHEN number = RowId    THEN DEFINITION
            ELSE 'GO'
        END
     FROM sources s
    JOIN (SELECT DISTINCT number FROM master.dbo.spt_values) n ON n.number BETWEEN RowId AND RowId+1

END
GO

-- Invokes ap_FindReferences procedure and writes scripted result to .sql file 
CREATE PROC ap_WriteReferences
@typeToFind VARCHAR(200)
AS
BEGIN

    DECLARE @sqlCmd VARCHAR(500)
    DECLARE @database VARCHAR(200) = 'test'
    DECLARE @outputFile VARCHAR(500) = 'c:\refences.sql'

    SET @sqlCmd = 'sqlcmd.exe -d '+@database+' -q "EXEC ap_FindReferences '''+ @typeToFind +'''" -o '+ @outputFile +' -h-1 -y0'

    EXEC xp_cmdshell @sqlCmd

END

Please pay attention to these notes if you are going to use it:

• you must change your database name and file name in ap_WriteReferences procedure
• it uses sys.sql_modules view to find references, hence it may not have most current information. It worked for me so far but still…
• please use it carefully, it drops objects and it is intended to dedicated development databases only (and at your own risk )
• it works only on SQL Server 2008 and higher
• extended properties are not scripted, it will be forgotten related objects are dropped

If you know any better way how to avoid this maintenance issue with UDDT, surely let me know! Also let me know here if you want me to include it as feature to my “pocket” SSMS productivity add-in.

RGSSC was quite life saver for me because you have quite few options of source control if you’re developing over dedicated local database. To make my life more comfortable I’ve developed SQL Treeo Add-In which allows me to create complex hierarchy of folders directly under my database bound to SVN. This folder (or groups) hierarchy is shared across all team members because this database is under source control. You can see short sample video here.

So all team members see the same picture of logical modules directly under our development database (green folders are created using SQL Treeo  Add-In):

Logical groups for objects within SSMS standard nodes can be created for all basic SQL objects – tables, views, stored procedures, functions and even for databases.

Jakub Dvorak

• Your domain object model must be very well designed and carefully mapped to relational data. ORM creates pressure to developer to sometimes “align” object model to relational model just because mapping could be done easier.
• It brings performance drawbacks especially during application startup
• You can easily misuse ORM without proper technical background of your ORM tool (such as nhibernate).
• You are limited what you can do with your SQL code. It applies to DDL and DML code as well.

If you are facing to complex SQL query you can use things like NHibernate criterias or  NHibernate Linq provider which may provide you way to build that kind of queries.

There are basically three scenarios where NHibernate is not helpful:

• Even more complex data retrieval query which you want to fine tune using e.g. SQL Server query hints.
• Any DML batch operation which affects more rows at one time
• Any complex application logic which require “batch approach” to your data and cannot be done “row-by-row” using your domain model manipulation and its mapping to relational data

For those scenarios, you must simply go lower in your application stack and deal with it directly in database. For first scenario you could use database views, for second and third you could use stored procedures mapped as named query in NHibernate.

Imagine even more complex application logic which must be implemented as stored procedures just because of performance – if you deploy your best developer skills such as encapsulation or reuse, you can deal with many stored procedures and functions (you can organize them with SQL Treeo Add-In in your SQL Server Management Studio).

I’ve identified very bad developer habit “do-it-at-application-layer-at-all-costs” which is that developer does even very complex SQL tasks using manipulating object model and ORM. Just not to dirty his code with some direct SQL. It inevitably leads to many row-by-tow operations and inefficient queries made by confused OR mapping components.

Head first – sometimes few stored procedures, functions or views at proper places could make better job than do-it-at-application-layer-at-all-costs.

Jakub Dvořák

SELECT @ClientType = ClientType, -- other columns
    FROM Client
    WHERE Id = @ClientId

IF (@clientType = 'SOMETYPE')
    -- do something

It is quite ok, but practice problem happened if you spread string constants representing lookup values over your T-SQL routines. This means that you have your ‘SOMETYPE’ constant defined on many places which is always not good for many reasons. If you would be in C# or other type-safe language you could afford to use constant static variables representing each lookup value and define their string values only at one place.

Such pseudo-hybrid code would look like this:

SELECT @ClientType = ClientType, -- other columns
    FROM Client
    WHERE Id = @ClientId

IF (@clientType = ClientType.SOMETYPE)
    -- do something

This is of course syntactically not correct in T-SQL but using CLR static variable might be good option.  There are few solutions how to implement “static” variables in T-SQL. Among better solutions belongs usage of UDF described e.g. here or very limited solution with CONTEXT_INFO described here.

I would like to describe other solution which uses SQL CLR User-Defined Type as static class for string constants. I am not going to describe what is CLR UDT and how to develop and deploy them, you can read it msdn.

First step is to write and deploy following UDT:

[Serializable()]
[SqlUserDefinedType(Format.UserDefined, MaxByteSize = -1)]
public struct ClientType : IBinarySerialize, INullable
{
    /// <summary>
    /// TypeA value
    /// 
    public static string TypeA { get { return "TYPEA"; } }

    ///
    /// TypeB value
    /// 
    public static string TypeB { get { return "TYPEB"; } }

    public void Read(BinaryReader r)
    {
        throw new NotImplementedException("Don't persist this UDT, it holds only constants.");
    }

    public void Write(BinaryWriter w)
    {
        throw new NotImplementedException("Don't persist this UDT, it holds only constants.");
    }

    public bool IsNull
    {
        get { throw new NotImplementedException(); }
    }

    public static ClientType Null
    {
        get
        {
            throw new NotImplementedException("Shouldn't have null value.");
        }
    }

    public override string ToString()
    {
        throw new NotImplementedException("Don't persist this UDT, it holds only constants.");
    }
    public static ClientType Parse(SqlString s)
    {
        throw new NotImplementedException("Don't persist this UDT, it holds only constants.");
    }

}

Second step is to use this UDT in your code:

SELECT @ClientType = ClientType, -- other columns
    FROM Client
    WHERE Id = @ClientId

IF (@clientType = ClientType::TypeA)
    -- do something

Now you have “strongly typed” lookup value used in your T-SQL code. Trick is that you can call static members of UDT from T-SQL by using “::” and completely avoid using string constants for lookups throughout your SQL code.

Jakub Dvorak

Who is interested in more deeper implementation view, read e.g. this article.

Jakub Dvorak

I decided to provide SQL Treeo for free.

I hope that this add-in will help others as it helped me.

Jakub Dvorak