Microsoft SQL Server Notes for Professionals (GoalKicker.com) (Z-Library)

# Microsoft SQL Server Notes for Professionals — Reading Guide ## 【One-Line Pitch】 A practical, example-driven reference for anyone who needs to write or maintain T-SQL in Microsoft SQL Server, covering everything from basic DML to data types, conversions, and query patterns. Ideal for beginners getting started with SQL Server and for professionals who want a quick, no-fluff refresher on everyday syntax. --- ## 【Book Arc】 - **Opening (~0%–20%)**: The book opens with the absolute fundamentals of Data Manipulation Language (DML) — INSERT, SELECT, UPDATE, DELETE — plus essential operations like TRUNCATE, transactions, and retrieving basic server information. This stage solves the "I need to write my first queries" problem with copy-paste-ready examples. - **Early (~20%–40%)**: Moves into the building blocks of schema design: the full catalog of SQL Server data types (exact/approximate numerics, date/time, character and Unicode strings, binary, and others), followed by data type conversion techniques using CAST, CONVERT, and the safer TRY_* variants. This stage addresses the "my data doesn't look right" problem. - **Middle (~40%–60%)**: Introduces User Defined Table Types (UDTs) — how to create them with primary keys, unique constraints, defaults, and multiple columns — then shifts to the SELECT statement in depth: WHERE filtering, ORDER BY sorting, GROUP BY aggregation, HAVING for group-level filters, TOP for limiting rows, and OFFSET-FETCH for pagination. This is the "querying with precision" stage. - **Late (~60%–80%)**: Covers alias naming conventions (AS, =, and implicit aliases) and then dives into the tricky world of NULLs: COALESCE, ISNULL, ANSI NULLS behavior, NULL comparison pitfalls, and the classic "NULL with NOT IN subquery" gotcha. This stage solves the "why is my query returning unexpected results" problem. - **Ending (~80%–100%)**: Wraps up with variables — declaring table variables, declaring multiple variables at once with initial values, and updating variables using both SELECT and SET. This stage covers the "how do I hold and manipulate values in my script" problem. --- ## 【Key Takeaways】 - **DML basics are the foundation** (Opening): INSERT, SELECT, UPDATE, and DELETE are presented with minimal theory and maximum examples — including variations like updating all rows, deleting all rows, and truncating. Master these first; everything else builds on them. - **Transactions protect data integrity** (Opening): The book shows how to wrap changes in transactions to keep data safe, a habit worth adopting before you write any production script. - **Know your data types before you design tables** (Early): Exact vs. approximate numerics, date/time formats, and character vs. Unicode strings are laid out clearly. Choosing the wrong type early causes conversion headaches later. - **TRY_CAST, TRY_CONVERT, and TRY_PARSE are your safety nets** (Early): Unlike their non-TRY counterparts, these return NULL instead of throwing errors on failed conversions — essential for cleaning messy data. - **User Defined Table Types enable reusable table structures** (Middle): Creating UDTs with primary keys, unique constraints, and default values lets you standardize table shapes across stored procedures and functions. - **SELECT is more than just "select *"** (Middle): The book systematically covers WHERE, ORDER BY, GROUP BY, HAVING, TOP, and OFFSET-FETCH — the full toolkit for shaping result sets, including pagination patterns. - **NULLs are a minefield** (Late): COALESCE vs. ISNULL, ANSI NULLS settings, and the "NULL with NOT IN subquery" trap are all covered. This is the chapter that will save you from debugging hours of mysterious empty result sets. - **Variables give scripts flexibility** (Ending): Declaring table variables and updating them via SELECT or SET is the bridge between writing one-off queries and building reusable scripts. --- ## 【Reading Tips】 - **Skim the DML chapter (Opening) if you already know SQL basics** — the examples are straightforward, but do read the transactions section carefully; it's easy to miss and important. - **Deep-read the data types and conversion chapters (Early)** — these are reference-heavy but worth absorbing because type mismatches are the #1 source of runtime errors. - **Pay special attention to the NULLs chapter (Late)** — it's short but dense with gotchas. The "NULL with NOT IN subquery" section alone is worth the price of the book. - **Use the SELECT chapter (Middle) as a lookup reference** — you don't need to memorize it; just know what's there (especially OFFSET-FETCH for pagination) and come back when you need it. - **Treat the whole book as a cookbook, not a novel** — each section is self-contained, so jump to the topic you need rather than reading cover to cover. --- ## 【Coverage Limits】 The excerpts cover roughly the first half of the table of contents (through variables). Later chapters — likely covering joins, stored procedures, functions, indexing, performance tuning, and advanced topics — are not represented in this guide. --- ##