Wayne Sheffield

My blog about SQL Server

Browsing Posts published by Wayne Sheffield

You know, these 1 hour sessions that are at most SQL Saturdays are just too short sometimes – you just get going and bang! The times up. There’s only so much material that can be presented in just one hour. And if there are a lot of questions, you may not have enough time to deliver all of the material that you prepared for. Recognizing this, my friend Jason Brimhall and I teamed up and created an all-day workshop for SQL training. We’ve been chugging around the country on the SQL Saturday Crazy Train doing this workshop, and our next stop will be in Louisville, KY. This workshop, titled “Murder They Wrote”, at SQL Saturday #403 on Thursday, August 20th, 2015.

And then we found out that our attendees want more information, on other topics. So we hooked up a caboose to our train, and on Friday, August 21st, 2015 we will be delivering a second all day workshop. This workshop is titled “A Masters Passport to Extended Events”.

It’s… Just…. Crazy!

And because it’s a Crazy Train, and we’re crazy, well, we have a crazy deal for you!

Yes, that’s right. You get both all day workshops for the price of one. Come to either one, or both, and pay the same price. You can see full details at our eventbrite site here.

Murder They Wrote

The Target Audience and what we cover

If you are a DBA, a database developer, or an application developer that connects to a SQL Server back-end database, then this session is for you. If you are experiencing performance issues, then this session is most definitely for you. If you’re looking for a fun way to spend a day and to get some #sqllearning, then this session is for you. This presentation is geared around decisions that have been made in the development life cycle and the effects that those decisions have on SQL Server, based upon the things that we have seen done to the instances that we have managed (and, in my case, some of the things that I did back when I was a developer and didn’t know better). With no topic being off limits, we also cover critical issues that just aren’t that great to do – and that still happen way too often. And demos? Oh yeah! You know that I like to show things instead of just telling them, so in that spirit, this is a demo-heavy presentation. We don’t just tell you that something is bad and something else is good… we’ll show it to you. We might even blow something up!

So, come on out for a day of learning, fun, and SQL camaraderie. We look forward to spending a day chatting with the attendees, and in helping them to overcome some of their issues.

The Official Session Abstract

Join Microsoft Certified Masters Wayne Sheffield and Jason Brimhall as they examine numerous crazy implementations they have seen over the years, and how these implementations can be murder on SQL Server. No topic is off limits as they cover the effects of these crazy implementations from performance to security, and how the “Default Blame Acceptors” (DBAs) can use alternatives to keep the developers, DBAs, bosses and even the end-users happy.

Course Objectives

  1. Recognize practices that are performance pitfalls
  2. Learn how to Remedy the performance pitfalls
  3. Recognize practices that are security pitfalls
  4. Learn how to Remedy the security pitfalls
  5. Demos, demos and even more demos – (and the scripts to demonstrate both the pitfalls and their remedies will be provided to attendees!)
  6. Have fun and discuss
  7. We might blow up a database

We are trying to have a nice mix of real world examples (and some contrived ones), all of which demonstrate a good and useful point.

A Masters Passport to Extended Events

As is commonly the case, all good things come to an end.  And now is as good a time as any for the use of SQL Trace and Profiler to come to an end.  Let’s face it, Trace was a good tool and had some wonderful uses.  Profiler for that matter was a good tool and was useful at times.

It is time to let those old tools retire gracefully and move into the world of XE.  This full day workshop will provide you the means to let Profiler and Trace be retired from your toolset as you discover all that XE has to offer.

This full day session on Extended Events will help prepare you to put this tool to immediate use as you walk back to your daily duties.  This workshop will teach you about Extended Events starting with the basics and moving through how to create XE sessions that will get the right data for you, while doing so with minimal impact.

You will be exposed to advanced troubleshooting techniques as we work through complex issues that are made easier through the use of XE.  Take advantage of this opportunity to dive into the world of Extended Events and learn how you can make best use of this tool in your SQL 2008+ environment.

Course Objectives

  1. Build a knowledge base for Extended Events
  2. Become familiar with the tools for Extended Events
  3. Become familiar with uses for Extended Events
  4. Get acquainted with troubleshooting scenarios for Extended Events
  5. Begin to put Extended Events to practical use
  6. Return to work with enough information to eradicate Profiler from the environment

 

Presented by:

WayneSheffieldWayne Sheffield, a Microsoft Certified Master in SQL Server, started working with xBase databases in the late 80′s. With over 25 years in IT, he has worked with SQL Server (since 6.5 in the late 90′s) in various dev/admin roles, with an emphasis in performance tuning. He is the author of several articles at www.sqlservercentral.com, a co-author of SQL Server T-SQL Recipes, and enjoys sharing his knowledge by presenting at SQL PASS events and blogging at http://blog.waynesheffield.com/wayne.

 

JasonBrimhallJason Brimhall has 10+ yrs experience and has worked with SQL Server from 6.5 through SQL 2012. He has experience in performance tuning, high transaction environments, as well as large environments. Jason also has 18 years experience in IT working with the hardware, OS, network and even the plunger (ask him sometime about that). He is currently a Consultant and a Microsoft Certified Master(MCM).

 

 

Registration – or what to do to join us

If you will be in the area, and you are looking for high quality content with a good mix of enjoyment (and some self-ridiculing), come and join us! You can register for this session at Eventbrite. There is a limit of available seats for this two day train stop, so sign up now to ensure that you have a spot saved for you! The cost is a mere $150 (plus EventBrite fees), and as previously mentioned, this covers either or both days!

And then, on Thursday August 20th and Friday August 21st, join us in Room 201 at the Indiana Wesleyan University, 1500 Alliant Avenue, Louisville KY 40299. The train gets underway at 8:30am (CDT). Don’t be left standing at the station!

But wait, there’s more!!!

Come on back Saturday for the main event – Louisville’s SQL Saturday is being held at the Indiana Wesleyan University, 1500 Alliant Avenue, Louisville KY 40299. There are 7 tracks going on, so there’s bound to be something there that you just have to see all day long! The complete session schedule is here, and Jason and I are each presenting throughout the day, so come on out and join one of us!

Related posts:

The Murder Train is pulling into Iowa City

The Murder Train is making a stop in Salt Lake City

The Murder Train chugs into Denver

The Murder Train chugs into Raleigh

SQL Saturday RVA recap

History of the SQL crazy train

Shameless plug:

Jason and I both present regularly at SQL Saturdays. If you are organizing an event and would like to have us deliver our workshop, please contact Jason, myself, or both of us.

A while back, I wrote a blog post showing the differences (including performance) between Inline Table-Valued Functions (ITVF) and Multi-Statement Table-Valued Functions (MSTVF). Since then, whenever I speak about ITVFs / MSTVFs, I’m frequently asked about how Scalar Functions (SF) perform. My stock answer has always been that they perform in a similar manner to a MSTVF, and that you should just try to use ITVFs whenever possible.

In this post, I’m going to do a head-to-head-to-head comparison of an ITVF, MSTVF and SF, all performing the same task. In order to show just the performance difference, the code inside the three functions is the same – the only differences is that necessary for that specific type of function.

For this test, I’m going to create a table with a VARCHAR(30) column. This column will hold numeric and some non-numeric characters. The test will be to return just the numeric characters from this string, in the order that they appear in the string.

The Test Data

In order to do a true performance test, you can’t test against just a few rows… you need to test against a bunch. So, let’s create a million row test table. I’ll do this in tempdb. The following script will create a column with numeric and non-numeric characters in it.

USE tempdb;
GO
IF OBJECT_ID('tempdb.dbo.#temp1', 'U') IS NOT NULL DROP TABLE #temp1;
WITH cteSymbols AS
(
SELECT  CharSymbol
FROM    (VALUES ('('), ('('), ('-'), (' '), ('-('), (')-'), ('.'), (','), ('/'), ('@')) dt (CharSymbol)
)
SELECT  TOP (1000000)
        IDENTITY(INTEGER) AS RowID,
        CONVERT(VARCHAR(30), s1.CharSymbol + CONVERT(VARCHAR(8), ABS(so1.object_id) % 10000000,0) +
                             s2.CharSymbol + CONVERT(VARCHAR(8), ABS(so2.object_id) % 10000000,0) +
                             s3.CharSymbol
               ) AS StringOfNumbersWithNonNumbers
INTO    #temp1
FROM    cteSymbols s1
CROSS JOIN cteSymbols s2
CROSS JOIN cteSymbols s3
CROSS JOIN sys.all_objects so1
CROSS JOIN sys.all_objects so2;
 
-- let's look at a few rows to see what we have
SELECT * FROM #temp1 WHERE RowID <= 10;
GO
A Sampling of the output to see what we're working with:
RowID StringOfNumbersWithNonNumbers
1 (4925397(4925397(
2 (8054770(4925397(
3 (2054713(4925397(
4 (6054656(4925397(
5 (6925511(4925397(
6 (925454(4925397(
7 (925169(4925397(
8 (2317107(4925397(
9 (9578706(4925397(
10 (5578763(4925397(

The Functions

The next step is to create the functions that the test will utilize:

-- Inline table valued function
IF OBJECT_ID('dbo.ITVF_TEST') IS NOT NULL DROP FUNCTION dbo.ITVF_TEST;
GO
CREATE FUNCTION dbo.ITVF_TEST (@Input VARCHAR(30))
RETURNS TABLE
WITH SCHEMABINDING
AS
RETURN
SELECT (SELECT SUBSTRING(@Input,N,1)
        FROM (VALUES (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13),(14),(15),(16),(17),(18),(19),(20),(21),(22),(23),(24),(25),(26),(27),(28),(29),(30)) AS x(N)
        WHERE N<=LEN(@Input)
        AND SUBSTRING(@Input,N,1) LIKE ('[0-9]')
        ORDER BY N
        FOR XML PATH(''), TYPE).value('.','VARCHAR(30)') AS StringNumbersOnly;
GO
 
-- Multi-statement table valued function
IF OBJECT_ID('dbo.MSTVF_TEST') IS NOT NULL DROP FUNCTION dbo.MSTVF_TEST;
GO
CREATE FUNCTION dbo.MSTVF_TEST (@Input VARCHAR(30))
RETURNS @Output TABLE (StringNumbersOnly VARCHAR(30))
WITH SCHEMABINDING
AS
BEGIN
    INSERT INTO @Output (StringNumbersOnly)
    SELECT (SELECT SUBSTRING(@Input,N,1)
            FROM (VALUES (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13),(14),(15),(16),(17),(18),(19),(20),(21),(22),(23),(24),(25),(26),(27),(28),(29),(30)) AS x(N)
            WHERE N<=LEN(@Input)
            AND SUBSTRING(@Input,N,1) LIKE ('[0-9]')
            ORDER BY N
            FOR XML PATH(''), TYPE).value('.','VARCHAR(30)') AS StringNumbersOnly;
    RETURN;
END;
GO
 
-- Scalar function
IF OBJECT_ID('dbo.SF_TEST') IS NOT NULL DROP FUNCTION dbo.SF_TEST;
GO
CREATE FUNCTION dbo.SF_TEST (@Input VARCHAR(30))
RETURNS VARCHAR(30)
WITH SCHEMABINDING
AS
BEGIN
    DECLARE @Output VARCHAR(30);
    SELECT @Output = (SELECT SUBSTRING(@Input,N,1)
            FROM (VALUES (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13),(14),(15),(16),(17),(18),(19),(20),(21),(22),(23),(24),(25),(26),(27),(28),(29),(30)) AS x(N)
            WHERE N<=LEN(@Input)
            AND SUBSTRING(@Input,N,1) LIKE ('[0-9]')
            ORDER BY N
            FOR XML PATH(''), TYPE).value('.','VARCHAR(30)');
    RETURN @Output;
END;
GO

Now that we have the data and functions, let’s look at what the functions are returning, and ensure that they are returning the same values:

SELECT  t.RowID,
        t.StringOfNumbersWithNonNumbers AS StringOfNumbers,
        dbo.SF_TEST(t.StringOfNumbersWithNonNumbers) AS ScalarFunction,
        MSTVF.StringNumbersOnly AS MultiStatementTVF,
        ITVF.StringNumbersOnly AS InlineTVF
FROM    #temp1 t
CROSS APPLY dbo.MSTVF_TEST(t.StringOfNumbersWithNonNumbers) MSTVF
CROSS APPLY dbo.ITVF_TEST(t.StringOfNumbersWithNonNumbers) ITVF
WHERE   t.RowID <= 10
ORDER BY t.RowID;
StringOfNumbers ScalarFunction MultiStatementTVF InlineTVF
(4925397(4925397( 49253974925397 49253974925397 49253974925397
(8054770(4925397( 80547704925397 80547704925397 80547704925397
(2054713(4925397( 20547134925397 20547134925397 20547134925397
(6054656(4925397( 60546564925397 60546564925397 60546564925397
(6925511(4925397( 69255114925397 69255114925397 69255114925397
(925454(4925397( 9254544925397 9254544925397 9254544925397
(925169(4925397( 9251694925397 9251694925397 9251694925397
(2317107(4925397( 23171074925397 23171074925397 23171074925397
(9578706(4925397( 95787064925397 95787064925397 95787064925397
(5578763(4925397( 55787634925397 55787634925397 55787634925397

The Performance Test

We can see that the data being returned by each of the functions is the same, so it’s time to compare the performance of the functions. This test will create a table to hold times for each function, and then will run each function individually against all of the rows in the table (inserting into the table just prior to and immediately after running the query). The results of the query calling the function will be sent to a new temporary table. When the testing is finished, we’ll get the duration for each function:

-- PERFORMANCE TESTING TIME!!!
-- table to store the times:
IF OBJECT_ID('tempdb.dbo.#temp2') IS NOT NULL DROP TABLE #temp2;
CREATE TABLE #temp2 (
    RowID INTEGER IDENTITY,
    FunctionName sysname,
    ActionDateTime DATETIME2(7) NOT NULL DEFAULT(SYSDATETIME()));
 
 
--------- INLINE TABLE-VALUED FUNCTION -----------
IF OBJECT_ID('tempdb.dbo.#ITVF_RESULTS') IS NOT NULL DROP TABLE #ITVF_RESULTS;
INSERT INTO #temp2 (FunctionName) VALUES  ('ITVF_TEST');
SELECT  *
INTO    #ITVF_RESULTS
FROM    #temp1
CROSS APPLY dbo.ITVF_TEST(StringOfNumbersWithNonNumbers)
INSERT INTO #temp2 (FunctionName) VALUES  ('ITVF_TEST');
 
 
--------- MULTI_STATEMENT TABLE-VALUED FUNCTION -----------
IF OBJECT_ID('tempdb.dbo.#MSTVF_RESULTS') IS NOT NULL DROP TABLE #MSTVF_RESULTS;
INSERT INTO #temp2 (FunctionName) VALUES  ('MSTVF_TEST');
SELECT  *
INTO    #MSTVF_RESULTS
FROM    #temp1
CROSS APPLY dbo.MSTVF_TEST(StringOfNumbersWithNonNumbers)
INSERT INTO #temp2 (FunctionName) VALUES  ('MSTVF_TEST');
 
 
--------- SCALAR FUNCTION ------------
IF OBJECT_ID('tempdb.dbo.#SF_Results') IS NOT NULL DROP TABLE #SF_Results;
INSERT INTO #temp2 (FunctionName) VALUES  ('SF_TEST');
SELECT  *, dbo.SF_TEST(StringOfNumbersWithNonNumbers) AS StringNumbersOnly
INTO    #SF_Results
FROM    #temp1;
INSERT INTO #temp2 (FunctionName) VALUES  ('SF_TEST');
 
 
 
---------- Show the testing results -----------
WITH cte AS
(
SELECT  t.FunctionName,
        DATEDIFF(MICROSECOND, MIN(t.ActionDateTime), MAX(t.ActionDateTime)) AS [Duration (microseconds)]
FROM    #temp2 t
GROUP BY t.FunctionName
)
SELECT  FunctionName,
        [Duration (microseconds)],
        CONVERT(NUMERIC(5,2), (cte.[Duration (microseconds)] * 1.0 / SUM(cte.[Duration (microseconds)]) OVER () * 1.0) * 100.0) AS PercentOfBatch
FROM    cte
ORDER BY [Duration (microseconds)];

The Results

FunctionName Duration (microseconds) PercentOfBatch
ITVF_TEST 11,961,481 4.36
SF_TEST 86,042,922 31.37
MSTVF_TEST 176,248,081 64.26

Which one of these would you prefer to be using? The ITVF is clearly the best performing. However, I expected to see the SF and the MSTVF being closer – the SF is twice as fast as the MSTVF. Notice that the MSTVF is an entire order of magnitude slower than the ITVF!

But Wait, There’s More!

No, this isn’t a commercial. But before we draw a conclusion, let’s try another test. For this test, let’s just do some simple string concatenation. To start off, we’ll make a test table with three columns, each with 5 random characters. The functions will just concatenate these columns together, with a space between the first two columns and a comma/space between the last two columns (this can be related to building a city+state+zip address line):

USE tempdb;
GO
IF OBJECT_ID('tempdb.dbo.#temp1') IS NOT NULL DROP TABLE #temp1;
WITH cte (Col) AS
(
-- get random characters
SELECT  CHAR(ABS(CHECKSUM(NEWID())) % 26 + 65)
FROM    sys.all_columns
)
SELECT  TOP (1000000)
        t1.Col + t2.Col + t3.Col + t4.col + t5.Col AS Col1,
        t5.Col + t3.col + t1.col + t2.col + t4.col AS Col2,
        t3.Col + t1.Col + t4.Col + t5.Col + t2.Col AS Col3
INTO    #temp1
FROM    cte t1
CROSS JOIN cte t2
CROSS JOIN cte t3
CROSS JOIN cte t4
CROSS JOIN cte t5;
GO
 
IF OBJECT_ID('dbo.ITVF_Test') IS NOT NULL DROP FUNCTION dbo.ITVF_Test;
IF OBJECT_ID('dbo.MSTVF_Test') IS NOT NULL DROP FUNCTION dbo.MSTVF_Test;
IF OBJECT_ID('dbo.SF_Test') IS NOT NULL DROP FUNCTION dbo.SF_Test;
GO
 
CREATE FUNCTION dbo.ITVF_Test (@Col1 VARCHAR(5), @Col2 VARCHAR(5), @Col3 VARCHAR(5))
RETURNS TABLE
WITH SCHEMABINDING
AS
RETURN SELECT @Col1 + ' ' + @Col2 + ', ' + @Col3 AS ReturnString;
GO
 
CREATE FUNCTION dbo.MSTVF_Test (@Col1 VARCHAR(5), @Col2 VARCHAR(5), @Col3 VARCHAR(5))
RETURNS @Results TABLE (ReturnString VARCHAR(20))
WITH SCHEMABINDING
AS
BEGIN
    INSERT INTO @Results (ReturnString)
    SELECT @Col1 + ' ' + @Col2 + ', ' + @Col3 AS ReturnString;
    RETURN
END
GO
 
CREATE FUNCTION dbo.SF_Test (@Col1 VARCHAR(5), @Col2 VARCHAR(5), @Col3 VARCHAR(5))
RETURNS VARCHAR(20)
WITH SCHEMABINDING
AS
BEGIN
    DECLARE @ReturnString VARCHAR(20);
    SET @ReturnString = @Col1 + ' ' + @Col2 + ', ' + @Col3;
    RETURN @ReturnString;
END
GO
For an explanation of how the randomization works, please see this article by SQL Server MVP Jeff Moden.
Once again, let’s compare the results of the functions:

-- Compare results
SELECT  TOP (10)
        ITVF.ReturnString AS ITVF,
        MSTVF.ReturnString AS MSTVF,
        dbo.SF_Test(Col1, Col2, Col3) AS SF
FROM    #temp1
CROSS APPLY dbo.ITVF_Test(Col1, Col2, Col3) ITVF
CROSS APPLY dbo.MSTVF_Test(Col1, Col2, Col3) MSTVF;
Which produces these results
ITVF MSTVF SF
OFOPV VOOFP, OOPVF OFOPV VOOFP, OOPVF OFOPV VOOFP, OOPVF
VFAMP PAVFM, AVMPF VFAMP PAVFM, AVMPF VFAMP PAVFM, AVMPF
MODCD DDMOC, DMCDO MODCD DDMOC, DMCDO MODCD DDMOC, DMCDO
BQQCQ QQBQC, QBCQQ BQQCQ QQBQC, QBCQQ BQQCQ QQBQC, QBCQQ
ZRBSB BBZRS, BZSBR ZRBSB BBZRS, BZSBR ZRBSB BBZRS, BZSBR
SKIRF FISKR, ISRFK SKIRF FISKR, ISRFK SKIRF FISKR, ISRFK
BZRWR RRBZW, RBWRZ BZRWR RRBZW, RBWRZ BZRWR RRBZW, RBWRZ
MPWHR RWMPH, WMHRP MPWHR RWMPH, WMHRP MPWHR RWMPH, WMHRP
JLAWD DAJLW, AJWDL JLAWD DAJLW, AJWDL JLAWD DAJLW, AJWDL
VZBKA ABVZK, BVKAZ VZBKA ABVZK, BVKAZ VZBKA ABVZK, BVKAZ

Okay, the functions are returning the same data, so let’s test their performance.

-- PERFORMANCE TESTING TIME!!!
-- table to store the times:
IF OBJECT_ID('tempdb.dbo.#temp2') IS NOT NULL DROP TABLE #temp2;
CREATE TABLE #temp2 (
    RowID INTEGER IDENTITY,
    FunctionName sysname,
    ActionDateTime DATETIME2(7) NOT NULL DEFAULT(SYSDATETIME()));
 
 
--------- INLINE TABLE-VALUED FUNCTION -----------
IF OBJECT_ID('tempdb.dbo.#ITVF_RESULTS') IS NOT NULL DROP TABLE #ITVF_RESULTS;
INSERT INTO #temp2 (FunctionName) VALUES  ('ITVF_TEST');
SELECT  *
INTO    #ITVF_RESULTS
FROM    #temp1
CROSS APPLY dbo.ITVF_TEST(Col1, Col2, Col3)
INSERT INTO #temp2 (FunctionName) VALUES  ('ITVF_TEST');
 
 
--------- MULTI_STATEMENT TABLE-VALUED FUNCTION -----------
IF OBJECT_ID('tempdb.dbo.#MSTVF_RESULTS') IS NOT NULL DROP TABLE #MSTVF_RESULTS;
INSERT INTO #temp2 (FunctionName) VALUES  ('MSTVF_TEST');
SELECT  *
INTO    #MSTVF_RESULTS
FROM    #temp1
CROSS APPLY dbo.MSTVF_TEST(Col1, Col2, Col3)
INSERT INTO #temp2 (FunctionName) VALUES  ('MSTVF_TEST');
 
 
--------- SCALAR FUNCTION ------------
IF OBJECT_ID('tempdb.dbo.#SF_Results') IS NOT NULL DROP TABLE #SF_Results;
INSERT INTO #temp2 (FunctionName) VALUES  ('SF_TEST');
SELECT  *, dbo.SF_TEST(Col1, Col2, Col3) AS StringNumbersOnly
INTO    #SF_Results
FROM    #temp1;
INSERT INTO #temp2 (FunctionName) VALUES  ('SF_TEST');
 
 
 
---------- Show the testing results -----------
WITH cte AS
(
SELECT  t.FunctionName,
        DATEDIFF(MICROSECOND, MIN(t.ActionDateTime), MAX(t.ActionDateTime)) AS [Duration (microseconds)]
FROM    #temp2 t
GROUP BY t.FunctionName
)
SELECT  FunctionName,
        [Duration (microseconds)],
        CONVERT(NUMERIC(5,2), (cte.[Duration (microseconds)] * 1.0 / SUM(cte.[Duration (microseconds)]) OVER () * 1.0) * 100.0) AS PercentOfBatch
FROM    cte
ORDER BY [Duration (microseconds)];

And the results are:

FunctionName Duration (microseconds) PercentOfBatch
ITVF_TEST 371,022 0.40
SF_TEST 3,356,192 3.63
MSTVF_TEST 88,856,118 95.97

Wow, this is even more impressive! Once again, the ITVF blows the other types of functions out of the water, being one order of magnitude faster than the SF and two (almost three) orders of magnitude faster than the MSTVF. The SF readily out-performs the MSTVF, being twenty-five times faster.

The Wrap Up

In the examples shown here, the ITVF clearly performs much better than either a SF or a MSTVF, and the MSTVF is also clearly the worst performing type of function, being orders of magnitude slower. However, as with all performance testing, you should test all three against a nice, large set of data (at least one million rows) for what you need the function to do, and utilize the best one for your needs.

I guess I’ll be changing my stock answer now… a SF is better than a MSTVF, but not as good as an ITVF.

SQLSat349You know, these 1 hour sessions that are at most SQL Saturdays are just too short sometimes – you just get going and bang! The times up. There’s only so much material that can be presented in just one hour. And if there are a lot of questions, you may not have enough time to deliver all of the material that you prepared for. Recognizing this, my friend Jason Brimhall and I teamed up and created an all-day workshop for SQL training. We will be chugging into Iowa City, IA on the SQL Saturday crazy train to deliver this workshop, titled “Pro Performance Tips & Tricks to a Faster, More Stable SQL Server” (aka “Murder They Wrote”), at SQL Saturday #394 on Friday, May 29th.

The Target Audience and what we cover

If you are a DBA, a database developer, or an application developer that connects to a SQL Server back-end database, then this session is for you. If you are experiencing performance issues, then this session is most definitely for you. If you’re looking for a fun way to spend a day and to get some #sqllearning, then this session is for you. This presentation is geared around decisions that have been made in the development life cycle and the effects that those decisions have on SQL Server, based upon the things that we have seen done to the instances that we have managed (and, in my case, some of the things that I did back when I was a developer and didn’t know better). With no topic being off limits, we also cover critical issues that just aren’t that great to do – and that still happen way too often. And demos? Oh yeah! You know that I like to show things instead of just telling them, so in that spirit, this is a demo-heavy presentation. We don’t just tell you that something is bad and something else is good… we’ll show it to you. We might even blow something up!

So, come on out for a day of learning, fun, and SQL camaraderie. We look forward to spending a day chatting with the attendees, and in helping them to overcome some of their issues.

The Official Session Abstract

Join Microsoft Certified Masters Wayne Sheffield and Jason Brimhall as they examine numerous crazy implementations they have seen over the years, and how these implementations can be murder on SQL Server. No topic is off limits as they cover the effects of these crazy implementations from performance to security, and how the “Default Blame Acceptors” (DBAs) can use alternatives to keep the developers, DBAs, bosses and even the end-users happy.

Presented by:

WayneSheffieldWayne Sheffield, a Microsoft Certified Master in SQL Server, started working with xBase databases in the late 80′s. With over 20 years in IT, he has worked with SQL Server (since 6.5 in the late 90′s) in various dev/admin roles, with an emphasis in performance tuning. He is the author of several articles at www.sqlservercentral.com, a co-author of SQL Server 2012 T-SQL Recipes, and enjoys sharing his knowledge by presenting at SQL PASS events and blogging at http://blog.waynesheffield.com/wayne.

 

 

 

JasonBrimhallJason Brimhall has 10+ yrs experience and has worked with SQL Server from 6.5 through SQL 2012. He has experience in performance tuning, high transaction environments, as well as large environments. Jason also has 18 years experience in IT working with the hardware, OS, network and even the plunger (ask him sometime about that). He is currently a Consultant and a Microsoft Certified Master(MCM).

 

 

Course Objectives

  1. Recognize practices that are performance pitfalls
  2. Learn how to Remedy the performance pitfalls
  3. Recognize practices that are security pitfalls
  4. Learn how to Remedy the security pitfalls
  5. Demos, demos and even more demos – (and the scripts to demonstrate both the pitfalls and their remedies will be provided to attendees!)
  6. Have fun and discuss
  7. We might blow up a database

We are trying to have a nice mix of real world examples (and some contrived ones), all of which demonstrate a good and useful point.

Registration – or what to do to join us

If you will be in the area, and you are looking for high quality content with a good mix of enjoyment (and some self-ridiculing), come and join us! You can register for this session at Eventbrite. There is a limit of available seats for this murder mystery theater, so sign up now to ensure that you have a spot saved for you. The cost is a mere $125 (plus EventBrite fees).

And then, on Friday May 29th, join us at the University Capitol Centre, Room 2520, located at 201 S Clinton St, Iowa City, IA 52240. The train gets underway at 8:30am (CDT). Don’t be left standing at the station!

But wait, there’s more!!!

Come on back Saturday for the main event – Iowa City’s SQL Saturday is being held at the University of Iowa – University Capitol Centre, 201 S Clinton St, Iowa City, Iowa, 52240. There are 5 tracks going on, so there’s bound to be something there that you just have to see all day long! The complete session schedule is here, and Jason and I are each presenting throughout the day, so come on out and join one of us!

Related posts:
The Murder Train is making a stop in Salt Lake City

The Murder Train chugs into Denver

The Murder Train chugs into Raleigh

SQL Saturday RVA recap

History of the SQL crazy train

Shameless plug:

Jason and I both present regularly at SQL Saturdays. If you are organizing an event and would like to have us deliver our workshop, please contact Jason, myself, or both of us.

Earlier this month, I hosted the 61st occurrence of the monthly TSQL-Tuesday blogging party. With a topic of “Giving Back”, it had a great turnout (27 party-goers). As I read through all of their posts, I noticed that many are planning to give back in pretty predictable ways – but there are some pretty surprising ways also. And this ended up giving me a way to do this (overdue) TSQL-Tuesday wrap-up: With this being the Christmas season, let’s do this wrap-up to the tune of “12 days of Christmas”.

 

For the new year, the SQL Community will give back: By having a more active blogging presence (19)

For the new year, the SQL Community will give back: By being involved as an organizer (in some capacity) of a local user group (11) or of a SQL Saturday (7) (18)

For the new year, the SQL Community will give back: By presenting at user groups, SQL Saturday’s , SQL Bits, PASS, SQL Intersections or other SQL events (17)

For the new year, the SQL Community will give back: By volunteering at user groups, SQL Saturdays or PASS (7)

For the new year, the SQL Community will give back: By sharing their knowledge (6)

For the new year, the SQL Community will give back: By writing books, articles, or white papers (4)

For the new year, the SQL Community will give back: By becoming more active on Twitter (notably on #sqlhelp) (4)

For the new year, the SQL Community will give back: By hosting a TSQL-Tuesday (3)

For the new year, the SQL Community will give back: By participating in their local user group (3)

For the new year, the SQL Community will give back: By helping others in whatever ways that they can (3)

For the new year, the SQL Community will give back: By helping people in online forums (2)

For the new year, the SQL Community will give back: By producing videos to help others (2)

This really turned out to encourage me more than I expected, and I really hope that everyone can do all that they hope.

And now, let’s recognize all of the party-goers with links to their awesome posts!

Warwick Rudd
Rob Farley
Garland MacNeill
Ben Miller
Paul Randal
Boris Hristov
Chris Yates
Angela Henry
Jim Dorame
Steve Thompson
Jason Brimhall
Kenneth Fisher
Andy Yun
Mike Donnelly
Lori Edwards
Rob Sewell
Andy Levy
Aaron Bertrand
Randy Knight
Catherine Wilhelmson
Ken Wilson
Wayne Sheffield
Dave Clary
Robert Pearl
Mike Tutor
Allen Kinsel
Malathi Mahadevan

TSQL2sDay150x150A little over 5 years ago, Adam Machanic (B|T) had this great idea of getting everyone in the SQL Community to all blog about a specific topic on the second Tuesday of the month. This monthly “blogging party” has a host, aka party organizer, that decides the theme. It has evolved: it goes by the name “T-SQL Tuesday”, it has its own Twitter hashtag (#TSQL2sDay), and monthly we are seeing more and more people joining in. For some people, this has become what draws them out of their shell to write something on their blog at all. This month starts the 6th year, and I want to thank Adam for giving this to our community.

This month, I’m the party organizer, and the theme that I had selected was Giving Back. Specifically, I asked:

In “The Spirit of Giving”, I want to know how you plan on Giving Back to the SQL Community during the coming year. Are you going to start speaking at your local user group? Speak at your local SQL Saturday? Perhaps step up and help run your local user group? Do you want to start becoming an active blogger – or increase your blogging? Do you plan on volunteering your time with larger organizations (such as PASS), so that SQL Training can occur at a larger level?

In order to decide how you want to improve, you need to take stock of what you’re currently doing. During 2014, I have (or will have) spoken at 12 SQL Saturdays across the United States (mostly in the East), where I’ve presented 16 sessions and I’ve co-presented 6 workshops (aka precons). Additionally, I’ve presented to three SQL User groups. Locally, I arrange the speakers for my local user group in Richmond, VA and I was a co-organizer for our SQL Saturday in March. For the PASS Summit, I served on the PowerPoint review committee. As far as writing goes, I’ve only blogged 16 posts on my blog, with 5 more on my work blog and 2 articles published at SQLServerCentral. And I just haven’t had the time to help out with online forums.

I’m happy with an average of 1 SQL Saturday per month. However, I really enjoy presenting, and I want to do more. What is missing here is presenting outside of PASS. Furthermore, I’d like to present internationally, though this does need to be at an English speaking location. I have plans for participating in SQL Summer Camp in June in Nova Scotia. And I’d like to present again at the PASS Summit.

Another area that is missing is giving back to user groups – I was shocked to see that I only presented at 3 during this year. I want to do better in this area during the upcoming year.

So, how I plan to Give Back to the SQL community during the coming year are:

Present to at least 1 SQL Saturday per month (average).
Post at least 1 blog post per month (outside of T-SQL Tuesday blog posts or my work blog).
Present at one non-PASS conference.
Submit to present to international conferences (SQL Bits, SQL Rally, etc.).
Present to at least 6 user groups. (Hey user group leaders – contact me!)
Submit four articles for submission at SQLServerCentral.
Participate more in online forums for SQL help.
I hope to be selected to be a volunteer with the PASS Summit again in some capacity.
And I’ll be the heading up our SQL Saturday event on March 21, 2015 (though we all know that this is a team operation).

And now I’ll ask everyone reading this to help hold me to these goals.

The Season of Giving

The annual PASS Summit (otherwise known as the #SQLFamily reunion) is over. Here in the United States, we have just finished celebrating Thanksgiving, where the average person consumes more calories in two hours than what they need for a week. And we are entering the season (that has now been active by merchants for months) where worldwide we try to out give (or, in merchant-speak, out-spend) everyone that we know – or at least to those that we are the closest to.

There are other ways of giving also. At this time of year, we find that food banks across the nation are receiving their largest food donations from the community. Underprivileged children that would otherwise not receive any gifts are receiving some, due to the community giving to organizations such as Toys-For-Tots (http://www.toysfortots.org/default.aspx). Other organizations, such as the Salvation Army (http://www.salvationarmy.org), are seen outside many stores raising money to fund all of the giving activities that they do worldwide throughout the year. Outside of this time of year, we see over and over that whenever there is a disaster that the worldwide community responds by giving donations and resources to help out. Of course the community gives all throughout the year in many other ways.

As the year wraps up, we find ourselves reminiscing about the past year, and in making resolutions for personal change for the coming year.

But hey, this is a SQL Blog. What does all of this have to do with SQL?

Well, I’m glad that you asked. You see, this month I’m the host for the monthly T-SQL blogging party known as T-SQL Tuesday. This party, which was started by Adam Machanic (blog|twitter) and is now starting its 6th year, is hosted by a different person each month. The host selects the theme, and then the blogging begins. Worldwide, on the second Tuesday of the month (all day, based on GMT time), bloggers attend this party by blogging about the theme. So, what theme am I selecting that I want you to blog about?

Giving Back

In “The Spirit of Giving”, I want to know how you plan on Giving Back to the SQL Community during the coming year. Are you going to start speaking at your local user group? Speak at your local SQL Saturday? Perhaps step up and help run your local user group? Do you want to start becoming an active blogger – or increase your blogging? Do you plan on volunteering your time with larger organizations (such as PASS), so that SQL Training can occur at a larger level? However you plan on giving back to the SQL Community during the upcoming year, and whether it is something new that you’ll be doing or continuing what you are doing, I’m looking forward to reading about it in your blog post.

How to participate

TSQL TuesdayAhh, your blog post. Now is a good time to discuss how you can attend this party. First off, your blog post needs to go live between 00:00 GMT Tuesday, December 9th, 2014 and 00:00 GMT Wednesday, December 10th, 2014. Secondly, your blog post needs to contain the T-SQL Tuesday logo image on this post, and it should link back to this post (trackbacks should work, but it’s a good idea to post a comment to this post with a link to your post). And optionally, tweet about your post using the #TSQL2sday hashtag.

Okay, you have a week to think about this, and to write your blog post. After the party, I’ll post a summary of what everyone has posted.

SQLSat349You know, these 1 hour sessions that are at most SQL Saturdays are just too short sometimes – you just get going and bang! The times up. There’s only so much material that can be presented in just one hour. Recognizing this, last year my friend Jason Brimhall and I teamed up and created an all-day workshop for SQL training. We will be chugging into Salt Lake City, UT on the SQL Saturday crazy train to deliver this workshop, titled “Murder They Wrote”, at SQL Saturday #349 on Friday, October 24th.

The Target Audience and what we cover

If you are a DBA, a database developer, or an application developer that connects to a SQL Server back-end database, then this session is for you. If you are experiencing performance issues, then this session is most definitely for you. If you’re looking for a fun way to spend a day and to get some #sqllearning, then this session is for you. This presentation is geared around decisions that have been made in the development life cycle and the effects that those decisions have on SQL Server, based upon the things that we have seen done to the instances that we have managed (and, in my case, some of the things that I did back when I was a developer and didn’t know better). With no topic being off limits, we also cover critical issues that just aren’t that great to do – and that still happen way too often. And demos? Oh yeah! You know that I like to show things instead of just telling them, so in that spirit, this is a demo-heavy presentation. We don’t just tell you that something is bad and something else is good… we’ll show it to you. We might even blow something up!

So, come on out for a day of learning, fun, and SQL camaraderie. We look forward to spending a day chatting with the attendees, and in helping them to overcome some of their issues.

The Official Session Abstract

Join Microsoft Certified Masters Wayne Sheffield and Jason Brimhall as they examine numerous crazy implementations they have seen over the years, and how these implementations can be murder on SQL Server. No topic is off limits as they cover the effects of these crazy implementations from performance to security, and how the “Default Blame Acceptors” (DBAs) can use alternatives to keep the developers, DBAs, bosses and even the end-users happy.

Presented by:

WayneSheffieldWayne Sheffield, a Microsoft Certified Master in SQL Server, started working with xBase databases in the late 80′s. With over 20 years in IT, he has worked with SQL Server (since 6.5 in the late 90′s) in various dev/admin roles, with an emphasis in performance tuning. He is the author of several articles at www.sqlservercentral.com, a co-author of SQL Server 2012 T-SQL Recipes, and enjoys sharing his knowledge by presenting at SQL PASS events and blogging at http://blog.waynesheffield.com/wayne.

 

 

 

JasonBrimhallJason Brimhall has 10+ yrs experience and has worked with SQL Server from 6.5 through SQL 2012. He has experience in performance tuning, high transaction environments, as well as large environments. Jason also has 18 years experience in IT working with the hardware, OS, network and even the plunger (ask him sometime about that). He is currently a Consultant and a Microsoft Certified Master(MCM). Jason is the VP of the Las Vegas User Group (SSSOLV).

 

 

Course Objectives

  1. Recognize practices that are performance pitfalls
  2. Learn how to Remedy the performance pitfalls
  3. Recognize practices that are security pitfalls
  4. Learn how to Remedy the security pitfalls
  5. Demos, demos and even more demos – (and the scripts to demonstrate both the pitfalls and their remedies will be provided to attendees!)
  6. Have fun and discuss
  7. We might blow up a database

We are trying to have a nice mix of real world examples (and some contrived ones), all of which demonstrate a good and useful point.

Registration – or what to do to join us

If you will be in the area, and you are looking for high quality content with a good mix of enjoyment (and some self-ridiculing), come and join us! You can register for this session at Eventbrite. There is a limit of 75 seats for this murder mystery theater, so sign up now to ensure that you have a spot saved for you. The cost is a mere $150 (plus EventBrite fees).

And then, on Friday October 24th, join us at the SSG Training Facility, located at 2975 West Executive Parkway, Lehi, UT 84043. The train gets underway at 9am.

But wait, there’s more!!!

Come on back Saturday for the main event – Salt Lake City’s SQL Saturday is being held at the Spencer Fox Eccles Business Building, 1655 Campus Center Dr, Salt Lake City, UT 84112. There are 10 tracks going on, so there’s bound to be something there that you just have to see all day long! The complete session schedule is here, and Jason and I are each presenting during the first session of the day, so come on out and join one of us!

Related posts:

The Murder Train chugs into Denver

The Murder Train chugs into Raleigh

SQL Saturday RVA recap

History of the SQL crazy train

Shameless plug:

Jason and I both present regularly at SQL Saturdays. If you are organizing an event and would like to have us deliver our workshop, please contact Jason, myself, or both of us.

SQLSat331You know, these 1 hour sessions that are at most SQL Saturdays are just too short sometimes – you just get going and bang! The times up. There’s only so much material that can be presented in just one hour. Recognizing this, last year my friend Jason Brimhall and I teamed up and created an all-day workshop for SQL training. We will be chugging into Denver, CO on the SQL Saturday crazy train to deliver this workshop, titled “Murder They Wrote”, at SQL Saturday #331 on Friday, September 19.

The Target Audience and what we cover

If you are a DBA, a database developer, or an application developer that connects to a SQL Server back-end database, then this session is for you. If you are experiencing performance issues, then this session is most definitely for you. If you’re looking for a fun way to spend a day and to get some #sqllearning, then this session is for you. This presentation is geared around decisions that have been made in the development life cycle and the effects that those decisions have on SQL Server, based upon the things that we have seen done to the instances that we have managed (and, in my case, some of the things that I did back when I was a developer and didn’t know better). With no topic being off limits, we also cover critical issues that just aren’t that great to do – and that still happen way too often. And demos? Oh yeah! You know that I like to show things instead of just telling them, so in that spirit, this is a demo-heavy presentation. We don’t just tell you that something is bad and something else is good… we’ll show it to you. We might even blow something up!

So, come on out for a day of learning, fun, and SQL camaraderie. We look forward to spending a day chatting with the attendees, and in helping them to overcome some of their issues.

The Official Session Abstract

Join Microsoft Certified Masters Wayne Sheffield and Jason Brimhall as they examine numerous crazy implementations they have seen over the years, and how these implementations can be murder on SQL Server.  No topic is off limits as they cover the effects of these crazy implementations from performance to security, and how the “Default Blame Acceptors” (DBAs) can use alternatives to keep the developers, DBAs, bosses and even the end-users happy.

Presented by:

WayneSheffieldWayne Sheffield, a Microsoft Certified Master in SQL Server, started working with xBase databases in the late 80′s. With over 20 years in IT, he has worked with SQL Server (since 6.5 in the late 90′s) in various dev/admin roles, with an emphasis in performance tuning. He is the author of several articles at www.sqlservercentral.com, a co-author of SQL Server 2012 T-SQL Recipes, and enjoys sharing his knowledge by presenting at SQL PASS events and blogging at http://blog.waynesheffield.com/wayne.

 

 

 

JasonBrimhallJason Brimhall has 10+ yrs experience and has worked with SQL Server from 6.5 through SQL 2012. He has experience in performance tuning, high transaction environments, as well as large environments.  Jason also has 18 years experience in IT working with the hardware, OS, network and even the plunger (ask him sometime about that). He is currently a Consultant and a Microsoft Certified Master(MCM). Jason is the VP of the Las Vegas User Group (SSSOLV).

 

 

Course Objectives

  1. Recognize practices that are performance pitfalls
  2. Learn how to Remedy the performance pitfalls
  3. Recognize practices that are security pitfalls
  4. Learn how to Remedy the security pitfalls
  5. Demos, demos and even more demos – (and the scripts to demonstrate both the pitfalls and their remedies will be provided to attendees!)
  6. Have fun and discuss
  7. We might blow up a database

We are trying to have a nice mix of real world examples (and some contrived ones), all of which demonstrate a good and useful point.

Registration – or what to do to join us

If you will be in the area, and you are looking for high quality content with a good mix of enjoyment (and some self-ridiculing), come and join us! You can register for this session at Eventbrite.  There is a limit of 30 seats for this murder mystery theater, so sign up now to ensure that you have a spot saved for you. The cost is a mere $125.

And then, on Friday September 19th, join us at the Cherry Creek Presbyterian Church – Community Life Center, located at 10150 E. Belleview Ave., Englewood, CO 80111. The train gets underway at 9am.

But wait, there’s more!!!

Come on back Saturday for the main event – Denver’s SQL Saturday is being held at University of Denver – Driscoll Student Center, 2055 East Evans Avenue, Denver, CO 80208. There are 8 tracks going on, so there’s bound to be something there that you just have to see all day long! The complete session schedule is here, and Jason and I are each presenting during the first session of the day, so come on out and join one of us!

Related posts:

The Murder Train chugs into Raleigh

SQL Saturday RVA recap

History of the SQL crazy train

Shameless plug:

Jason and I both present regularly at SQL Saturdays. If you are organizing an event and would like to have us deliver our workshop, please contact Jason, myself, or both of us.

TSQL TuesdayWell, here it is again. The second Tuesday of the month, which means that it’s T-SQL Tuesday. T-SQL Tuesday… that wonderful monthly blogging party started by Adam Machanic (Blog | @AdamMachanic). The intent is to get the entire SQL Community together on a monthly basis to blog about a common theme – to get each person’s perspective on the chosen subject. This month, it is being hosted by Jeffrey Verheul (Blog | @DevJef), and the topic he has chosen is SQL Family and Community. Jeffrey lays out the topic like this:

This month I would like to give everyone the opportunity to write about SQL Family. The first time I heard of SQL Family, was on Twitter where someone mentioned this. At first I didn’t know what to think about this. I wasn’t really active in the community, and I thought it was a little weird. They were just people you meet on the internet, and might meet in person at a conference some day. But I couldn’t be more wrong about that!Once you start visiting events, forums, or any other involvement with the community, you’ll see I was totally wrong. I want to hear those stories. How do you feel about SQL Family? Did they help you, or did you help someone in the SQL Family? I would love to hear the stories of support, how it helped you grow and evolve, or how you would explain SQL Family to your friends and family (which I find hard). Just write about whatever topic you want, as long as it’s related to SQL Family or community.

I think that this is a wonderful topic. Thank you Jeffrey for selecting this. The #SQLFamily, and the entire SQL community is so fantastic, and this is a wonderful opportunity to shine the light on it. So, what is #SQLFamily? How would you explain it to others? Well, let’s start off with what is family? It’s simply all the people that you are related to. So, #SQLFamily is all the people that you know through SQL Server.

However, #SQLFamily isn’t just about who they are; it’s also about what they are. They are the SQL community. Unlike Other RDBMS platforms, the #SQLFamily openly shares what they know. From folks writing online articles at places like sqlservercentral.com and their own blogs or books. Presenters at user groups, SQLSaturdays, or larger conferences like the PASS Summit. Or perhaps what is most unique about our SQL community is the folks that help out on the #SQLhelp twitter “group”. You see, most of these do it for free (or in the case of SQLSaturday, it comes out of their own pocket). Okay, those that write books get paid for that, and there might be a pittance for some articles, but almost everything else is all volunteering, of both time and money. But they don’t try to hog the spotlight – they are just trying to help and encourage others in all things SQL Server.

Why would they do this? Some may be craving name recognition, maybe even perhaps hoping for a boost in their career. But I’d venture that most are like me, and they like helping others learn. When you get feedback of how you’ve helped someone, or you see the light go on in someone’s eyes while speaking, it is such an incredible rush. When you have taught someone something, you have changed the world. Talk about paying it forward!

My first exposure to #SQLFamily was at my local user group. There, I was encouraged to apply myself – to write and to present. Little did I realize just how much this would make me grow myself, but I suspect that those encouraging me knew.

But this isn’t all that that #SQLFamily is about. It’s also about what else you do away from SQL. The #SQLFamily encourages each other in all kinds of areas. Runners get encouragement where the #SQLFamily tweets messages to them while they are running. We sponsor each other for things that are important to each other (like polar plunges for charity). Or like Brent and Grant are doing for Summit this year and wearing funky leggings for a good cause. We get together for fun nights of SQLKaraoke. When you are down, or if something unfortunate happens, someone is there to lift you up and to offer support. And like all families, we grow. Spouses get added to the mix, and they become part of our #SQLFamily also, sometimes an active part.

So there you have it… my recap of what SQLFamily is all about. Thanks again Jeffrey for the topic, and I look forward to reading what everyone else has posted.

SQLSat320

You know, these 1 hour sessions that are at most SQL Saturdays are just too short sometimes – you just get going and bang! The times up. There’s only so much material that can be presented in just one hour. Recognizing this, last year my friend Jason Brimhall and I teamed up and created an all-day workshop for SQL training. We will be chugging into Raleigh, NC on the SQL Saturday crazy train to deliver this workshop, titled “Murder They Wrote”, at SQL Saturday #320 on Friday, September 5.

The Target Audience and what we cover

If you are a DBA, a database developer, or an application developer that connects to a SQL Server back-end database, then this session is for you. If you are experiencing performance issues, then this session is most definitely for you. If you’re looking for a fun way to spend a day and to get some #sqllearning, then this session is for you. This presentation is geared around decisions that have been made in the development life cycle and the effects that those decisions have on SQL Server, based upon the things that we have seen done to the instances that we have managed (and, in my case, some of the things that I did back when I was a developer and didn’t know better). With no topic being off limits, we also cover critical issues that just aren’t that great to do – and that still happen way too often. And demos? Oh yeah! You know that I like to show things instead of just telling them, so in that spirit, this is a demo-heavy presentation. We don’t just tell you that something is bad and something else is good… we’ll show it to you. We might even blow something up!

So, come on out for a day of learning, fun, and SQL camaraderie. We look forward to spending a day chatting with the attendees, and in helping them to overcome some of their issues.

The Official Session Abstract

Join Microsoft Certified Masters Wayne Sheffield and Jason Brimhall as they examine numerous crazy implementations they have seen over the years, and how these implementations can be murder on SQL Server.  No topic is off limits as they cover the effects of these crazy implementations from performance to security, and how the “Default Blame Acceptors” (DBAs) can use alternatives to keep the developers, DBAs, bosses and even the end-users happy.

Presented by:

WayneSheffieldWayne Sheffield, a Microsoft Certified Master in SQL Server, started working with xBase databases in the late 80′s. With over 20 years in IT, he has worked with SQL Server (since 6.5 in the late 90′s) in various dev/admin roles, with an emphasis in performance tuning. He is the author of several articles at www.sqlservercentral.com, a co-author of SQL Server 2012 T-SQL Recipes, and enjoys sharing his knowledge by presenting at SQL PASS events and blogging at http://blog.waynesheffield.com/wayne.

 

 

 

JasonBrimhallJason Brimhall has 10+ yrs experience and has worked with SQL Server from 6.5 through SQL 2012. He has experience in performance tuning, high transaction environments, as well as large environments.  Jason also has 18 years experience in IT working with the hardware, OS, network and even the plunger (ask him sometime about that). He is currently a Consultant and a Microsoft Certified Master(MCM). Jason is the VP of the Las Vegas User Group (SSSOLV).

 

 

Course Objectives

  1. Recognize practices that are performance pitfalls
  2. Learn how to Remedy the performance pitfalls
  3. Recognize practices that are security pitfalls
  4. Learn how to Remedy the security pitfalls
  5. Demos, demos and even more demos – (and the scripts to demonstrate both the pitfalls and their remedies will be provided to attendees!)
  6. Have fun and discuss
  7. We might blow up a database

We are trying to have a nice mix of real world examples (and some contrived ones), all of which demonstrate a good and useful point.

Registration – or what to do to join us

If you will be in the area, and you are looking for high quality content with a good mix of enjoyment (and some self-ridiculing), come and join us! You can register for this session at Eventbrite.  There is a limit of 24 seats available for this murder mystery theater, so sign up now to ensure that you have a spot saved for you. The cost is a mere $110.

And then, on Friday September 5th, join us at the Courtyard by Marriott Raleigh North at the Triangle Town Center (3401 Sumner Boulevard, Raleigh, NC 27616). The train gets underway at 9am. Yes, it’s at a hotel, which means that if you’re from out-of-town, you can stay here and just wander downstairs.

But wait, there’s more!!!

Come on back Saturday for the main event – Raleigh’s SQL Saturday is being held at Wake Tech Northern Campus, 6600 Louisburg Road, Raleigh, NC 27616. There are 8 tracks going on, so there’s bound to be something there that you just have to see all day long! The complete session schedule is here. (If you are staying at the Courtyard, it’s only 3 miles away.)

Related posts:

SQL Saturday RVA recap

History of the SQL crazy train

Shameless plug:

Jason and I both present regularly at SQL Saturdays. If you are organizing an event and would like to have us deliver our workshop, please contact Jason, myself, or both of us to make arrangements.