This book stands out of the myriads of books written on the topic. This is not your ordinary T-SQL book that goes over a syntax and teaches you when to use WHERE and when - HAVING. In that aspect, the title is slightly misleading - the book goes much deeper than just "learn T-SQL querying". In fact, the book is on par with the "deep dive" volumes on the topic, and oftentimes goes even deeper - all without losing clarity and overwhelming readers with noisy details.

The uniqueness of this volume is in the fact that it not only tells the reader to do "this" and not do "that", but goes on explaining _why_ you should be doing the former and not doing the latter. The authors actually captured respective SQL Server execution plans to illustrate what happens under the hood when you do "this" and when you do "that", so readers can see the _why_ with their own eyes. The number of scenarios covered is also quite plenty.

From SQL parsing to query optimizing to actual execution, the authors guide the reader through all the stages of a query life cycle. I was especially impressed with the query optimization phase coverage, as this book provides you with the information no other book does - how the Query Optimizer rules work, and what kinds of "knobs" (query hints, trace flags) you can use to influence their internal workings. Once you build this kind of understanding, it enables you to see patterns in your own queries, "think" like SQL Server if you wish. And that thought process will make you well-rounded and much more versatile in writing queries that are efficient and scale well.

You've been writing queries for at least a year or two, and you're curious about what's happening under the hood when SQL Server runs a query. You want to know what you can do to improve your queries, tune your indexes, and change SQL Server's configuration settings so that your results will return faster.

This book is for curious people like you. It is by no means a level 100, here's-how-to-write-a-query book. The first couple dozen pages act as if they're a gentle on-ramp to the parts of a query, but just jump past those to chapter 2, understanding query processing, and the authors start getting into how a query is optimized.

Or if you're not quite so curious, and you just want faster queries, jump to chapter 6 and learn about anti-patterns.

That is probably my only objection to the book - it seems just a little bit out of order, with some really challenging concepts coming before the easier parts about simple things you can do to make your queries go faster. That's easy to work around, however: just read the Table of Contents, find the parts that interest you, and hit those first. This is the kind of book that rewards repeated reading, and beyond that, rewards using the book's contents as a jumping-off point for additional learning. When I first read the Table of Contents, I wondered how the authors were going to cover so much ground in ~450 pages - and they did a great job striking a balance between giving you enough to get started, versus dragging you into the weeds with obscure internals details.

Highly recommended for folks who want to start a curious journey into SQL Server query execution and tuning.

Lots of tips in this book and the explanations are very clear.

Good book. Got what I was expecting.

First and foremost, this book lives up to its subtitle: developing efficient and elegant T-SQL code. There's a significant amount of information packed into its pages. For instance, great detail is given into reading an execution plan and breaking down all the information provided from the types of operations SQL Server is performing to the resources SQL Server is committing to execute the query. The authors have also provided information explaining how SQL Server's optimization engine has changed over the years and the reasons for that change. Part of that is explaining why some queries which perform well on older versions don't perform as well on the newer versions. That's important to know if you're performing migrations and upgrades.

Another aspect of this book I like is the coverage of anti-patterns: typical T-SQL code we see that can tremendously impact performance negatively. However, the authors don't just say, "Stop it!" They also provide execution plans and explanations detailing WHY something performs poorly and should be considered an anti-pattern.

Finally, the authors address a significant issue when it comes to query tuning: finding the queries performing badly over time. It's easy to locate poorly performing queries right now. SQL Server provides DMVs for just that purpose. But unless a DBA is monitoring the system 24x7, we need a way of capturing what's executing and how well it's executing. There's a chapter dedicated to just that: capturing the information over a period of time. Subsequent chapters cover how to break that information and compare the performance over time.

This is definitely a book I'd recommend to anyone looking to improve their T-SQL writing skills. I've been working with SQL Server and writing queries for over 20 years and I found the authors cover information that I didn't know. As a previous reviewer (Brent Ozar) indicated, this isn't a book to teach you how to write queries. There are beginning SQL and T-SQL books for that. However, if you have at least that basic knowledge, this book will teach you how to write T-SQL queries better.

I am still working through the chapters of this books, but I will say just within the first 4 chapters I've learned how to investigate bottlenecks in my Stored Procedures, and I've learned how to dissect the Query Execution Plan.

This book jumps right into it, occasionally can be difficult to follow but if you're willing to spend time looking up terms that are not defined and that you're not familiar with, this will be a great asset to have in your book shelf.

YouTube videos will cover more topics than this book. Don’t waste your money.

Fantastic book, written by part of the SQL Server team. This covers more than just writing tSql queries; it provides a real insight into how the product processes your queries and why.

Vielleicht ist das Buch super. Ich habe ein Buch gesucht das einem hilft gute T-SQL Queries zu schreiben. Das auf Fallstricke usw. hinweist und einem Wege aufzeigt wie man möglichst optimale Queries schreibt. Bisher ist das Buch sehr administrativ, es wird viel über SQL Server Versionen geschrieben und Exekution plans. Das mag alles ganz interessant und vielleicht auch zielführend sein. Etwas mehr SQL-Statments und daran erklären was darunter gut bzw. schlecht ist, fände ich besser.

Stored Procedures werden nur kurz erwähnt.