SQL Server | R4

Here are my choice of links for the past week.

SQL Server:
- Gail Shaw’s SQL Server Deadlocks by Example provides a good overview of deadlocks in SQL Server, with advice on how to detect and avoid them.
- Thomas Kejser’s Clustered Indexes vs. Heaps analyses common table usage scenarios to determine whether using clustered indexes is a good option.
- Keeping with the clustered index subject, Marcus Winand’s Unreasonable Defaults: Primary Key as Clustering Key provides a detailed analysis of what a clustered index is and how it affects other existing table indexes, leading to the (implied) question of whether setting a primary key as a clustered index is a good option at all.
- Juergen Thomas’s New functionality in SQL Server 2014 – Part 2 – New Cardinality Estimation explains the role of cardinality estimation in query execution, addresses the changes in cardinalily estimation in SQL Server 2014 and provides some examples of how the changes affect query execution. An excellent read.
- Paul White’s Cardinality Estimation for Multiple Predicates also addresses the subject of cardinality estimation, but covers the use of multiple predicates in a query. The article shows how the default behavior can be avoided through the use of trace flags. It also addresses the changes in cardinality estimation and the use of related trace flags in SQL Server 2014.
- Thomas LaRock’s How to: restore the master database in SQL Server 2012 shows how the master database can be restored in a SQL Server 2012 instance.
- Tim Wieman’s Scaling-out SQL Server disks and data files on Windows Azure Virtual Machines…a real-world example provides an example of scaling out disks and data files (in this case for TempDB) on an Azure VM. The article includes many useful reference links.
- Hugo Kornelis’s Generating Test Data in TSQL addresses test data generation, in a situation where the data needs to follow a distribution and columns are not independent.
- Brent Ozar’s How to Query the StackExchange Databases shows how the Stack Exchange databases can be accessed and queried, both through a browser or actually downloading the data to a local instance of SQL Server. If you ever need real data for query tuning, the article shows a way to get it.
- Glen Berry’s SQL Server Diagnostic Information Queries for January 2014 includes the latest version of the author’s diagnostic information queries.

Web Design and Development:
- Jon Galloway’s ASP.NET – A last look back at 2013, looking ahead to 2014 is a good overview of what happened with ASP.NET during 2013 and what to expect in 2014, with links to many resources relevant for those who work with ASP.NET.
- Shawn Wildermuth’s Why Should You Care About NodeJS? explains what .NET developers can learn from NodeJS and why they should have a look at it and consider using it in some projects.
- Steve Hansen’s HTML5: Myths and misconceptions provides a bit of history on HTML 5 and tries to debunk some of the rising myths about what it is and what it offers.
- Jonathan Cutrell’s Web Design 2014: What to Watch Out For makes some predictions on what to expect on the field of web design, for 2014.
- Pete Hodgson’s Keeping jQuery in Check proposes a segregated DOM to avoid the pitfalls of what the author describes as ‘jQuery soup’, an indiscriminate intermingling of $ references, AJax calls, application logic and business rules.

Big Data / BI:
- Josh Polsky and Yaniv Mor’s ETL – Is it Still Relevant? states that ETL is still very much relevant in big data scenarios and explains why.
- Merv Adrian’s AAA is Not Enough Security in the Big Data Era argues for the need of anonymization or deidentification in an era, where big data will be increasingly used for medical, commercial and security reasons.
- Alexei Khalyako’s Expanding HDP Hadoop file system to Azure Blob Storage shows how to take advantage of the cheap cost and scalability of Azure Blob Storage, expanding available storage beyond the 16TB available in a HD Insight cluster.
- Rob Kerr’s Submitting C# MapReduce jobs on Windows Azure HDInsight is a video showing how to create and execute C# MapReduce jobs on Azure’s HDInsight.

That’s it for this week. Thanks for reading.

This post is meant to be part of January 2014 edition of T-SQL Tuesday, a rotating blog party started by Adam Machanic (@AdamMachanic | blog). This month’s edition is hosted by Hemanth.D (@SQLChow | blog) and the topic is automation:

“Automation plays a huge part in our lives and the DBA profession is not so different. A couple of years ago this topic was shared by Pat Wright. I would like to revisit this again and see how much of our approach has changed.”

At the beginning there was a shell script

My first serious dabbling with computing started back in college, and at the time, Unix was the only operating system around. Windows was still to be created and scripting was the natural way to do things, other than creating programs in a language such as C or Fortran. Back then I already preferred programming to just about anything else and didn’t have any administration responsibilities, so I wrote a few scripts, but can’t say I was very proficient. This really didn’t change much after graduation and even though I had the chance to try stuff in other scripting languages, such as perl, I confess I was never a heavy scripter.

Oh, that amazing and dreadful GUI

Then, of course, the GUI came about and it didn’t really contribute to change the state of things very much. GUIs are pretty much amazing, when you want to have an easy life. A few clicks here and there and things are done.This works fine when your needs are confined to a database at a time,the GUI makes it really easy to do most of the things. The reverse of this is, of course, a bit of incentive not to really delve into things, especially when time is short and the GUI is nice and good enough to do what you need.

Ok, now repeat it 80 times

GUIs are not so nice when whatever you need to do, needs to be done not once or twice, but many times, in a repeated manner. I think my first encounter with automation in SQL Server was 10 years ago, when I found myself responsible for 80 undergrads and had to provide them with databases and proper access to such databases, as part of the database design course I was going to teach. The solution was obvious – write a simple T-SQL script, creating the databases, the logins, the users, the permissions and make sure everything works fine. Of course, while you are at it, write one script to clean everything up when the semester ends.

Since that first time, the T-SQL script has become a good friend. Although my automation needs are not very pressing, it is usually based in T-SQL. even if s part of a bigger SSIS package and directed with timely precision under the guidance of the SQL Server Agent. On my company, we really only host development servers, so this fulfills our automation needs rather well.

Repetition, yet again

Things will probably change soon, since we are launching a new application that will, mean the need to deal with a big number of databases (hundreds or even thousands). Expecting our automation needs to change because of that, we’re looking into other options, including the obvious Powershell, but also considering the possibility of developing apps that can make our expected tasks easier. Its’ even a bit of a coincidence that this topic should be the subject of this month’s T-SQL Tuesday, since we are evaluating our options for automation at this very moment. I will certainly be looking at the contribution of the SQL Server community for additional insight on this matter.

R4

Random Ramblings (on Technology, Programming and Databases,) by Rui Ribeiro

Tag Archives: SQL Server

My links of the week – January 19, 2014

T-SQL Tuesday #50 – Automation – When repetition is really what you want