Learn your way! Get started

SQL Server 2005: Developer

with experts Andy Baron, Don Kiely


Course at a glance

Included in these subscriptions:

  • Dev & IT Pro Video
  • Dev & IT Pro Power Pack
  • Power Pack Plus

Release date Release date 11/15/2007
Level Level Advanced
Runtime Runtime 24h 2m
Closed captioning Closed captioning N/A
Transcript Transcript N/A
eBooks / courseware eBooks / courseware Included
Hands-on labs Hands-on labs Included
Sample code Sample code Included
Exams Exams Included
Platform Platform Internet Explorer Only


Enterprise Solutions
Enterprise Solutions

Need reporting, custom learning tracks, or SCORM? Learn More



Course description

SQL Server 2005 includes a rich set of tools that go beyond the basics of querying and manipulating data. In this course, you will learn about processing large amounts of data, handling complex data structures, implementing asynchronous messaging, working with XML, integration services, implementing security, and the new Business Intelligence (BI) suite.

Meet the experts

Andy Baron Andy Baron is a nationally recognized industry expert specializing in Visual Basic, Visual C#, ASP.NET, ADO.NET, SQL Server, and SQL Server Business Intelligence. He is an experienced consultant, author, and editor for several industry publications and speaker at industry conferences. Andy has also been repeatedly selected as a Microsoft MVP for his contributions to Microsoft's online support.

Don Kiely Don Kiely is a featured instructor on many of our SQL Server and Visual Studio courses. He is a nationally recognized author, instructor, and consultant specializing in Microsoft technologies. Don has many years of teaching experience, is the author or co-author of several programming books, and has spoken at many industry conferences and user groups. In addition, Don is a consultant for a variety of companies that develop distributed applications for public and private organizations.


Course outline



Module 1

Inserting Data (32:57)
  • Introduction (04:41)
  • Inserting Data (07:08)
  • Set a Database Context (00:27)
  • Inserting a Single Value (01:08)
  • Suppress Rows Affected (00:53)
  • Using SET NOCOUNT ON (02:24)
  • Retrieving Identity Values (04:14)
  • Dealing with Delimiters (03:56)
  • Inserting Multiple Rows (01:20)
  • Insert Using a SELECT clause (02:38)
  • Insert Using SELECT INTO (02:56)
  • Summary (01:05)
Advanced Inserting Data (20:23)
  • Introduction (01:42)
  • Temporary Tables (02:53)
  • Create a Temp Table (01:16)
  • Using CREATE TABLE (01:00)
  • Global Temp Tables (01:13)
  • Inserting with Output (07:17)
  • Using BULK INSERT (03:58)
  • Summary (01:00)
Updating and Deleting Data (21:03)
  • Introduction (00:56)
  • Updating a Single Row (02:25)
  • Updating Multiple Rows & Col. (01:12)
  • Updating from Another Table (01:05)
  • Updating with TOP (02:06)
  • Updating with UPDATE.WRITE (08:18)
  • Deleting a Single Row (00:49)
  • Deleting Multiple Rows (00:10)
  • Delete All Rows (00:21)
  • Using TRUNCATE TABLE (01:20)
  • Summary (02:17)

Module 2

Transaction Isolation (35:40)
  • Introduction (01:08)
  • Isolation Levels Explained (00:24)
  • READ COMMITTED (03:06)
  • READ UNCOMMITTED (01:06)
  • REPEATABLE READ (02:22)
  • SERIALIZABLE (00:37)
  • Blocking and Deadlocks (04:05)
  • EAD COMMITTED Demo (03:54)
  • EAD UNCOMMITTED Demo (05:20)
  • Using Snapshot Isolation (00:48)
  • Snapshot Isolation Caveats (01:06)
  • Enabling Snapshot Isolation (02:43)
  • SNAPSHOT ISOLATION (03:27)
  • View Code Used to Clean Up (04:47)
  • Summary (00:41)
T-SQL Functions (34:59)
  • Introduction (02:20)
  • Batches and Scripts (03:51)
  • Variables (03:41)
  • Delimiters and Operators (00:24)
  • Using CAST (02:29)
  • Type Coercion & Precedence (01:39)
  • Data Type Precedence (02:51)
  • Using an Explicit Cast (01:18)
  • Using CONVERT (02:59)
  • Using CONVERT with Style (02:49)
  • Using STR (01:10)
  • Working with Nulls (02:32)
  • IS NULL (00:01)
  • ISNULL (01:30)
  • NULLIF (01:27)
  • COALESCE (02:49)
  • Summary (01:01)
More on T-SQL Functions (36:58)
  • Introduction (00:38)
  • IsNumeric (02:35)
  • RAND (02:55)
  • ROUND (02:35)
  • Combining RAND and ROUND (02:39)
  • REPLACE and STUFF (01:36)
  • LEN, LEFT, and RIGHT (00:37)
  • SUBSTRING (00:53)
  • CHARINDEX (02:32)
  • PATINDEX (03:49)
  • SPACE (00:55)
  • CHAR and ASCII (00:53)
  • LOWER and UPPER (00:07)
  • Case-insensitive Filtering (00:53)
  • COLLATE (01:53)
  • LTRIM and RTRIM (00:33)
  • GETDATE (00:10)
  • MONTH, DAY, and YEAR (00:16)
  • DATEPART and DATENAME (00:48)
  • DATEADD and DATEDIFF (02:29)
  • @@ROWCOUNT (01:44)
  • @@IDENTITY (01:13)
  • @@TRANCOUNT (00:20)
  • @@ERROR (02:24)
  • Summary (01:17)

Module 3

T-SQL Flow Control (25:42)
  • Introduction (02:08)
  • Using IF...ELSE (01:56)
  • Using BEGIN...END (03:21)
  • Using GOTO (01:43)
  • Using RETURN (03:40)
  • Using CASE (04:16)
  • Replace IIF/Conditional (03:20)
  • Using WHILE (02:05)
  • Using WAITFOR (02:25)
  • Summary (00:44)
T-SQL Ranking Functions (13:50)
  • Introduction (02:13)
  • New Ranking Func. Explained (05:27)
  • UnitPrice, Listed by UnitPrice (01:44)
  • UnitPrice, Listed by ProdName (00:53)
  • Rank Using PARTITION (01:05)
  • Overall, Listed by ProdName (01:27)
  • Summary (00:58)
Transactions (31:49)
  • Introduction (01:50)
  • Passing the ACID Test (01:56)
  • Features that Support ACID (01:34)
  • Transaction Types (02:26)
  • Isolation Levels & Transactions (01:09)
  • Transactions and Locking (01:55)
  • Viewing Lock Information (00:58)
  • Deadlocks: The Problem (02:20)
  • Deadlocks: Solutions (06:00)
  • Creating Transactions in Apps. (00:33)
  • Designing Trans. Support (03:04)
  • Creating Efficient Transactions (02:28)
  • Compile/Runtime Errors (01:00)
  • Compile Trans. Error Demo (02:08)
  • Runtime Trans. Error Demo (02:03)
  • Summary (00:17)
Explicit Trans./Error Handling (38:04)
  • Introduction (01:08)
  • Creating Explicit Transactions (02:48)
  • Using @@TRANSCOUNT (01:20)
  • T-SQL Error Handling in Trans. (02:43)
  • Using Simple Error Handling (01:12)
  • Stored Procs to Manage Trans. (02:17)
  • Err. Handling in a Stored Proc. (07:43)
  • Error Severity Levels Explained (01:36)
  • Creating a User-Defined Error (01:59)
  • Using Try/Catch (01:58)
  • Try/Catch Details (02:30)
  • Error Handling Functions (01:12)
  • Display Detailed Error Info. (01:11)
  • RAISERRROR in a Try/Catch (04:41)
  • Trans. with XACT_STATE (01:57)
  • Using SET XACT_ABORT ON (01:04)
  • Summary (00:36)

Module 4

Creating Views (42:51)
  • Introduction (01:53)
  • Why Use Views? (01:47)
  • Views and Security (02:15)
  • View Rules (06:26)
  • Syntax and Options (06:48)
  • Creating Views Using SSMS (10:38)
  • Alter a View (02:38)
  • Script View as a SELECT (00:29)
  • Creating Views from Templates (03:44)
  • Try to Create a Sorted View (03:31)
  • Summary (02:38)
Working with Views (45:39)
  • Introduction (00:38)
  • Some View Examples (00:29)
  • Mailing Label View Example (01:19)
  • View Example Using Top (05:07)
  • Correlated Subquery View Ex. (02:34)
  • View Example Using a JOIN (01:01)
  • Derived Tables & Nesting View (03:41)
  • Common Table Expressions (03:36)
  • Encrypting View Definitions (02:09)
  • Using CHECK OPTION (02:08)
  • Updating Rules (02:52)
  • Updating Views (01:01)
  • Views w/ Computed Column (00:57)
  • Updating Views with Joins (01:12)
  • Creating a Computed Column (02:44)
  • IsPersisted Prop./PERSISTED (02:19)
  • Indexed View Explained (00:26)
  • Indexed View Requirements (03:46)
  • Partitioned Views (06:15)
  • Summary (01:16)

Module 5

Stored Procedures (42:49)
  • Introduction (01:21)
  • Stored Procedure Features (03:27)
  • SP Performance Benefits (07:38)
  • Using Schema Qualifiers (03:07)
  • Reasons to Use SPs (03:26)
  • Stored Procedure Syntax (02:09)
  • Creating Stored Procedures (05:34)
  • Using Parameters in a SP (04:04)
  • Returning Results from a SP (05:03)
  • Return Values in a Result Set (01:28)
  • Using Variables in SPs (02:46)
  • Limitations in Statements (01:58)
  • Summary (00:42)
Stored Proc. Debug./Triggers (33:01)
  • Introduction (01:10)
  • Debugging SPs with PRINT (02:44)
  • Other SP Debugging Tips (03:14)
  • Overview of Creating Triggers (04:34)
  • Uses / Limits for Triggers (02:10)
  • Trouble with Triggers (03:42)
  • How Triggers Work (03:04)
  • How to Create Triggers (01:34)
  • Creating Triggers Demo (02:42)
  • INSTEAD OF Trigger Demo (03:14)
  • DDL Triggers (01:43)
  • Stop Adding a Table Trigger (01:39)
  • Drop a DDL Trigger (00:38)
  • Summary (00:46)

Module 6

User-Defined Functions (36:16)
  • Introduction (01:27)
  • Scalar Functions (00:31)
  • Inline Table-Valued Function (01:28)
  • Multi-Statement Table-Valued (02:04)
  • CLR Functions Explained (01:51)
  • Create a Scalar Function (05:36)
  • Scalar Function w/Parameters (03:09)
  • User-Defined Function Options (05:06)
  • Call Scalar Func. w/Param. (02:58)
  • Create an Inline TVF (02:32)
  • Calling an Inline TVF (03:51)
  • Inline Function w/Parameters (01:24)
  • Update From Inline Function (03:06)
  • Summary (01:05)
Multi-Statement Functions (18:27)
  • Introduction (01:32)
  • Create a Multi-Statement Func. (06:02)
  • Call a Multi-Statement Function (01:30)
  • Filter on a Field (01:58)
  • Join Functions to Tables (01:25)
  • Use within Scalar Function (02:26)
  • Use within a Subquery (02:26)
  • Summary (01:04)
Using .NET Code (39:05)
  • Introduction (01:26)
  • Hosting .NET Code (02:38)
  • Ways to Use SQLCLR (00:44)
  • Enabling SQLCLR (00:41)
  • Enabling SQLCLR Demo (01:27)
  • Writing SQLCLR Code (01:13)
  • SQLCLR Code Manually (05:51)
  • SQLCLR Code Using VS 2005 (06:51)
  • SQL Data Types (02:40)
  • Data Type Comparison (01:17)
  • Accessing Local Data (03:23)
  • Returning Results (03:07)
  • Return Data w/ Stored Proc. (03:40)
  • Return Rows of Data (03:21)
  • Summary (00:39)

Module 7

SQLCLR Code Modules (40:10)
  • Introduction (00:49)
  • Stored Procedures/Triggers (02:55)
  • Creating an SQLCLR Trigger (03:55)
  • Test the New Trigger (03:26)
  • User-Defined Functions (01:56)
  • Create a Hashing UDF (00:54)
  • Test the Hashing UDF (00:59)
  • Aggregates (04:49)
  • Create a Concatenate Aggreg. (00:51)
  • View C.A. Code (09:00)
  • System Catalogs (00:25)
  • View sys.assemblies (01:24)
  • View sys.assembly_files (02:02)
  • View sys.assembly_modules (00:41)
  • sys.procedures/sys.triggers (00:46)
  • Debugging Using Visual Studio (02:50)
  • Viewing Loaded Assemblies (01:10)
  • Profiler/Performance Counters (00:34)
  • Summary (00:35)
SQLCLR Security (20:00)
  • Introduction (01:18)
  • Broken SQLCLR Code Demo (02:09)
  • Code Access Security (CAS) (05:32)
  • SQLCLR Permission Sets (04:02)
  • Fixed SQLCLR Code Demo (01:32)
  • SET TRUSTWORHY ON (01:36)
  • Benefit of SQLCLR Code (02:13)
  • Summary (01:36)
Planning/Configuring Full Text (27:39)
  • Introduction (01:23)
  • Advant. of Full-Text Search (05:51)
  • Full-Text Enhancements in '05 (00:15)
  • Indexing Performance (01:05)
  • DDL (01:02)
  • Integrated Backup/Restore (01:14)
  • XML Support (01:14)
  • Thesaurus Support (00:33)
  • Multi-Language Support (02:08)
  • FT Search T-SQL Queries (01:59)
  • Create a Full-Text Index Demo (10:33)
  • Summary (00:18)

Module 8

Full-Text Search Queries (27:33)
  • Introduction (00:32)
  • Writing Full-Text Queries (02:19)
  • CONTAINS Predicate (02:12)
  • CONTAINS with Simple Terms (01:50)
  • CONTAINS w/ Gen. Terms (01:37)
  • CONTAINS with Thesaurus (00:31)
  • View/Modify the Thesaurus (06:23)
  • CONTAINS with Prefix Terms (00:30)
  • CONTAINS w/ Proximity Terms (00:57)
  • FREETEXT Predicate (01:26)
  • Ranking Relevance (01:48)
  • Joins to Fetch Text Values (00:58)
  • Limiting the Number of Results (02:38)
  • Use Weights to Influence Rank (00:37)
  • Using Full-Text DDL (01:37)
  • Summary (01:31)
FOR XML AUTO/RAW (21:39)
  • Introduction (01:54)
  • Using AUTO Mode (04:50)
  • Nesting Hierarchy in AUTO (02:31)
  • Adding a Root Element (00:49)
  • Generate Elements in AUTO (01:25)
  • Generating XML Schema (02:52)
  • Using RAW Mode (01:25)
  • Naming the Row Element (01:17)
  • Generate Elements in RAW (00:55)
  • Including Null Values (02:47)
  • Summary (00:49)
FOR XML EXPLICIT/PATH (31:41)
  • Introduction (01:28)
  • Using FOR XML EXPLICIT (01:23)
  • Constructing the UNION Query (04:11)
  • Special Column Aliases (05:22)
  • Using PATH Mode (00:22)
  • Elements/Subelements/Attrib. (04:22)
  • Subqueries to Nest Results (06:30)
  • PATH Mode Col. Alias Exp. (06:03)
  • Summary (01:56)

Module 9

APPLY & Common Table Exp. (29:55)
  • Introduction (01:36)
  • Using APPLY (00:16)
  • Comparing APPLY/Using Joins (01:36)
  • Using CROSS/OUTER APPLY (02:22)
  • Things We Can't Do with a Join (04:37)
  • APPLY w/ Table-Valued Func. (02:30)
  • Combine APPLY w/ FXP (03:32)
  • Creating Recursive Queries (00:31)
  • Classic Recursive Queries (06:51)
  • Recursive Query Using a CTE (05:24)
  • Summary (00:36)
Pivot and Dynamic SQL (33:38)
  • Introduction (01:27)
  • Col. into Headings w/ PIVOT (02:57)
  • QUOTENAME / SQL Injection (04:40)
  • Converting Nulls to Zeros (01:44)
  • Using Dynamic SQL (01:05)
  • Overcoming PIVOT Limitations (09:24)
  • Parameters w/ sp_executesql (09:53)
  • Summary (02:24)
Pivot/Dynamic SQL Cont. (25:56)
  • Introduction (01:31)
  • Using QUOTENAME() (03:06)
  • Defend Against SQL Injection (03:24)
  • QUOTENAME with Quotes (02:18)
  • Output w/ sp_executesql (03:46)
  • Signing Stored Proc. w/ Cert. (02:12)
  • Create a Signed Cert. Demo (07:02)
  • Test the Signed Certificate (01:01)
  • Run the Clean Up Code (00:29)
  • Summary (01:03)

Module 10

Partitions (15:47)
  • Introduction (00:45)
  • Table-based Partitioning (00:39)
  • Why Partition? (01:45)
  • Partition History in SQL Server (05:07)
  • Range Partitions (01:05)
  • Partition Key (01:55)
  • Multiple Filegroups (02:43)
  • Index Partitioning (01:24)
  • Summary (00:19)
Create Partitioned Tables (20:34)
  • Introduction (00:38)
  • Overview (00:51)
  • Create Partition Function (00:49)
  • LEFT/RIGHT Boundaries (02:58)
  • Demo: Partition Function (01:46)
  • Datetime Values (01:15)
  • Partition Scheme (04:17)
  • Demo: Partition Scheme (01:11)
  • Create Table/Index (02:25)
  • Demo: Create Table/Index (03:53)
  • Summary (00:25)
Query Partitions (37:32)
  • Introduction (00:41)
  • Overview (01:01)
  • $PARTITION Function (02:31)
  • Demo: $PARTITION (05:41)
  • Catalog Views (01:25)
  • sys.partition_functions (00:42)
  • sys.partition_range_values (00:18)
  • sys.partition_schemes (00:22)
  • sys.data_spaces (00:22)
  • Demo: Catalog Views (02:26)
  • Manage Partitions (00:30)
  • Mod Part Tables/Indexes (00:28)
  • Mod Partition Function (01:56)
  • Split Partitions (03:36)
  • Merge Partitions (03:44)
  • Switch Partitions (03:19)
  • Modify Partition Scheme (01:39)
  • Backup Partitions (02:13)
  • Performance Considerations (02:29)
  • Summary: Partitions (01:33)
  • Summary (00:26)
Work with Nulls (24:47)
  • Introduction (00:37)
  • Overview (00:18)
  • SqlTypes vs. CLR Types (03:35)
  • System.Data.SqlTypes (02:34)
  • Review: SqlTypes/CLR Types (01:41)
  • ANSI_NULLS Option (00:33)
  • Demo: ANSI_NULLS Option (04:28)
  • NULLs and SqlBoolean (02:12)
  • Demo: NULLs and SqlBoolean (02:31)
  • Assign NULL Values (00:39)
  • CLR Integration (00:23)
  • Direct Assignment (00:50)
  • NULLIF / COALESCE (00:55)
  • Demo: Assign NULL Values (01:18)
  • Demo: COALESCE (01:42)
  • Summary (00:23)

Module 11

Ranking (14:21)
  • Introduction (00:33)
  • Grouped Data (00:55)
  • ROW_NUMBER (01:15)
  • RANK (01:09)
  • DENSE_RANK (00:32)
  • Demo: ROW_NUMBER (01:57)
  • Demo: RANK (02:05)
  • Demo: DENSE_RANK (01:15)
  • NTILE (02:10)
  • Demo: NTILE (02:09)
  • Summary (00:15)
Correlated Subqueries (19:00)
  • Introduction (00:32)
  • Overview (00:58)
  • Subquery Basics (01:15)
  • Correlated Subquery (03:12)
  • Where Clause (01:37)
  • ANY / SOME / ALL Modifiers (01:02)
  • Demo: Subquery (01:31)
  • HAVING (02:03)
  • UPDATE (01:26)
  • JOINS / Temp Tables (04:59)
  • Summary (00:18)
CTE"s (18:30)
  • Introduction (00:41)
  • Overview (01:22)
  • CTE Syntax (03:03)
  • Recursive CTE (05:13)
  • Demo: Recursive CTE (07:55)
  • Summary (00:13)
Complex Data / Structures (27:20)
  • Introduction (00:36)
  • Overview (00:24)
  • Data Type Precedence (02:15)
  • Explicit Conversion w/CAST (01:32)
  • IMPLICIT Conversion (01:02)
  • Multinational Data (03:14)
  • Collation Labels (01:52)
  • Collation Precedence (02:06)
  • Demo: COLLATE Clause (03:30)
  • Query Hierarchical Data (01:37)
  • Multi-Referential (00:49)
  • Adjacency List (02:28)
  • Demo: CTE w/Recursion (05:26)
  • Summary (00:24)
Write Efficient Queries (19:32)
  • Introduction (00:41)
  • Overview (01:37)
  • EXISTS Clause (02:05)
  • Demo: EXISTS Clause (03:12)
  • JOINS vs. Subqueries (05:07)
  • One-Pass Queries (01:00)
  • Demo: One-Pass Queries (05:20)
  • Summary (00:26)

Module 12

Write Efficient Queries 2 (25:41)
  • Introduction (00:33)
  • Multiple ResultsSets (00:58)
  • Temporary Tables (04:54)
  • Table Variables (04:29)
  • UDFs (03:31)
  • Demo: UDFs (10:43)
  • Summary (00:30)
Write Efficient Queries 3 (20:23)
  • Introduction (00:35)
  • Common Table Expression (01:34)
  • Demo: CTEs (03:40)
  • Worktables (01:44)
  • Demo: Worktables (12:31)
  • Summary (00:17)
Working w/Complex Query (23:03)
  • Introduction (00:40)
  • Overview (00:58)
  • Implicit Transactions (03:48)
  • Demo: Implicit Transactions (03:35)
  • Use Sub Tasks (03:33)
  • Demo: Use Sub Tasks (10:08)
  • Summary (00:18)

Module 13

Maintain Query Files (27:03)
  • Introduction (00:37)
  • Overview (01:23)
  • Source Control (02:05)
  • Visual SourceSafe (02:24)
  • Put Files in Source Control (00:45)
  • Demo: Source Control (06:26)
  • Keyword Expansion/Comment (02:44)
  • Enable Keyword Expansion (01:15)
  • Demo: Keyword Expansion (02:37)
  • Version Information (01:18)
  • Demo: Retrieve Version Info (03:04)
  • Demo: Compare Versions (01:54)
  • Summary (00:25)
XML Data Types (25:19)
  • Introduction (00:32)
  • Overview (01:01)
  • Declare XML Objects (00:57)
  • Demo: XML Data Type (02:51)
  • XML Data Type Restrictions (01:54)
  • Load XML Data (00:43)
  • Demo: Load XML Data (02:09)
  • SELECT...FOR XML (01:44)
  • Demo: SELECT...FOR XML (02:07)
  • Bulk Load w/OPENROWSET (02:13)
  • Demo: OPENROWSET (02:45)
  • Indexing Columns (03:42)
  • Demo: Indexing Columns (02:08)
  • Summary (00:26)
XML Schema Collections (25:32)
  • Introduction (00:43)
  • Overview (00:58)
  • Typed/Untyped XML (01:30)
  • Schema Basics (01:08)
  • Demo: Examine XSD File (04:26)
  • Register Schemas (02:39)
  • Demo: Register Schema (06:55)
  • View Stored Schema (01:44)
  • Catalog Views/Functions (00:27)
  • sys.xml_schema_collections (00:29)
  • sys.xml_schema_namespaces (00:25)
  • sys.xml_schema_components (01:33)
  • xml_schema_namespace (02:01)
  • Summary (00:28)
Query XML (26:15)
  • Introduction (00:37)
  • Overview (00:41)
  • XQuery (01:21)
  • query() Method (00:26)
  • value() Method (00:53)
  • exist() Method (00:45)
  • modify() Method (00:26)
  • nodes() Method (00:40)
  • Demo: XQuery (04:58)
  • FOR XML (01:05)
  • OPENXML (03:37)
  • Demo: FOR XML (05:48)
  • Demo: OPENXML (04:32)
  • Summary (00:21)

Module 14

Best Practices (10:07)
  • Introduction (00:39)
  • XML Support (03:20)
  • Storing XML (01:31)
  • Index XML Columns (02:30)
  • Querying (01:33)
  • Summary (00:32)
Introducing SSIS (30:16)
  • Introduction (02:45)
  • When to Use SSIS (01:36)
  • SSIS Architecture (05:15)
  • Import and Export Wizard (07:09)
  • Package Development Tools (03:11)
  • Control Flow Design Surface (02:49)
  • Data Flow Design Surface (02:36)
  • Event Handlers Design Surface (00:37)
  • Package Explorer DS (00:55)
  • Execute Package Utility (03:05)
  • Summary (00:12)
Building an SSIS Package (17:49)
  • Introduction (01:46)
  • SSIS Demo: Import Orders (04:52)
  • Data Flow Design Surf. Demo (07:35)
  • Truncated Fields (00:42)
  • Running the Design Flow (01:03)
  • Progress Tab (01:08)
  • Summary (00:40)
Add Control/Data Flow Tasks (30:00)
  • Introduction (01:07)
  • Add a Task to Control Flow (02:55)
  • Transform / Clean Up Data (05:40)
  • Tips on Date/Time Conversion (00:49)
  • Adding a Script Component (09:32)
  • Defining the Destination (04:38)
  • Mapping Input/Output Columns (01:05)
  • Organizing the Data Flow (00:26)
  • TRUNCATE the Order Table (01:35)
  • Review the Output (01:10)
  • Summary (00:58)

Module 15

Troubleshooting Packages (11:30)
  • Introduction (00:54)
  • Starting Package Logging (00:43)
  • Choosing What to Log (02:40)
  • Review Visual Warnings (01:10)
  • Execution Results (00:54)
  • Create a Data Viewer (03:47)
  • Break Points (00:56)
  • Summary (00:22)
Analysis Services Overview (35:38)
  • Introduction (01:28)
  • The Problem (01:24)
  • The Solution (01:50)
  • Fact Table / Measures (00:57)
  • Dimension Table (00:30)
  • Dimensions / Cubes (04:37)
  • Dimensional DB Schemas (02:01)
  • Cube Storage: MOLAP (01:39)
  • Cube Storage: ROLAP (00:49)
  • Cube Storage: HOLAP (01:00)
  • Cube Storage: Partitions (00:29)
  • Unified Dimensional Model (08:28)
  • UDM: Perspectives (00:45)
  • UDM: KPIs (01:12)
  • UDM: Attribute Semantics (01:48)
  • UDM: Custom Aggregations (01:37)
  • UDM: Write-Back (01:13)
  • UDM: Actions (01:08)
  • UDM: Security (02:06)
  • Summary (00:26)
Creating a Cube (39:36)
  • Introduction (00:55)
  • AdventureWorksDW Sample (03:25)
  • Creating a Data Source View (02:01)
  • Create a New Data Source (00:21)
  • Define Connection Information (03:00)
  • Define Impersonation Info. (02:08)
  • Create the Data Source View (03:34)
  • View DSV Designer (01:06)
  • Create Friendly Table Names (01:00)
  • View Relationships of Tables (01:27)
  • Add/Modify Relationships (00:29)
  • Create a New Cube (02:05)
  • Detect/View Fact/Dim. Tables (02:25)
  • Select a Time Dimension Table (01:56)
  • Select / Modify Measures (02:04)
  • Review / Modify New Dim. (02:19)
  • Cube Designer: Cube Structure (01:04)
  • CD: Dimension Usage (01:22)
  • CD: Calculations / KPIs (01:11)
  • CD: Actions / Partitions (00:30)
  • CD: Perspectives (00:25)
  • CD: Translations (00:24)
  • CD: Browser (00:15)
  • Deploy the Cube (02:49)
  • Reload in the Browser (00:48)
  • Summary (00:20)

Module 16

Browsing & Enhancing Cubes (26:54)
  • Introduction (00:44)
  • Browse the Cube Data (03:54)
  • Add to the Subcube Area (01:17)
  • Modify Properties of a Measure (02:43)
  • Modify Attrib. in a Dimension (01:45)
  • Organize Attrib. into a Folder (01:15)
  • Modify the Hierarchy (02:55)
  • Rebuild / Deploy the Project (01:22)
  • Add a New Named Calculation (04:19)
  • Bind the New Named Calc. (01:24)
  • Browse the Modified Cube (03:48)
  • Summary (01:22)
Data Mining (30:15)
  • Introduction (01:07)
  • Data Mining Algorithms (07:09)
  • Creating a Data Mining Project (01:25)
  • Create New Data Source View (01:35)
  • Define a Relationship (00:50)
  • Create a New DM Structure (04:30)
  • Set Algorithm Parameters (01:35)
  • Build / Deploy the Structure (00:47)
  • Process / View DM Model (01:42)
  • Inspecting the Data (00:20)
  • Filter the Itemsets (01:42)
  • Probability / Importance (02:19)
  • View the Dependency Network (01:47)
  • Adjust Link Strength (01:17)
  • Summary (02:03)
Reporting Services (14:08)
  • Introduction (01:15)
  • Server Components (03:17)
  • Report Server Demo (02:22)
  • Command Prompt Utilities (00:31)
  • Client Components (01:12)
  • Reporting Services Req. (00:52)
  • Reporting Services Installation (00:58)
  • Using the Configuration Tool (03:26)
  • Summary (00:10)
Creating Reports (17:15)
  • Introduction (00:29)
  • Report Server Wizard (04:47)
  • Build a Report From Scratch (01:11)
  • Create a New DataSource (01:02)
  • Create a New DataSet (01:03)
  • Add Data to the Report (02:16)
  • Preview the Report (00:42)
  • Deploy the Report (01:06)
  • View the Report (00:39)
  • Using/Managing Pub. Reports (00:53)
  • Exploring the Report Manager (00:53)
  • Upload a Report File (01:45)
  • Summary (00:22)