Muutke küpsiste eelistusi

Designing Database Solutions by Using Microsoft® SQL Server 2005: MCITP Self-Paced Training Kit (Exam 70-441) [Multiple-component retail product]

4.00/5 (10 hinnangut Goodreads-ist)
  • Formaat: Multiple-component retail product, 656 pages, kõrgus x laius: 235x187 mm, Contains 1 Paperback / softback and 1 CD-ROM
  • Ilmumisaeg: 12-Sep-2007
  • Kirjastus: Microsoft Press,U.S.
  • ISBN-10: 0735623422
  • ISBN-13: 9780735623422
Teised raamatud teemal:
  • Multiple-component retail product
  • Hind: 58,95 €*
  • * saadame teile pakkumise kasutatud raamatule, mille hind võib erineda kodulehel olevast hinnast
  • See raamat on trükist otsas, kuid me saadame teile pakkumise kasutatud raamatule.
  • Kogus:
  • Lisa ostukorvi
  • Tasuta tarne
  • Lisa soovinimekirja
Designing Database Solutions by Using Microsoft® SQL Server 2005: MCITP Self-Paced Training Kit (Exam 70-441)Suurem pilt
  • Formaat: Multiple-component retail product, 656 pages, kõrgus x laius: 235x187 mm, Contains 1 Paperback / softback and 1 CD-ROM
  • Ilmumisaeg: 12-Sep-2007
  • Kirjastus: Microsoft Press,U.S.
  • ISBN-10: 0735623422
  • ISBN-13: 9780735623422
Teised raamatud teemal:
Püsilink: https://www.kriso.ee/db/9780735623422.html
Märksõnad:
EXAM PREP GUIDE

Ace your preparation for the skills measured by MCITP Exam 70-441and on the job. Work at your own pace through a series of lessons and reviews that fully cover each exam objective. Then, reinforce what youve learned by applying your knowledge to real-world case scenarios and practice exercises. This official Microsoft study guide is designed to help you make the most of your study time.

Maximize your performance on the exam by learning to:





Develop solutions that support business strategy Design attributes and define entities and entity relationships Create programmatic database objects using T-SQL and CLR Define data access requirements and work with schemas to manage objects Design reporting solutions with SQL Server Reporting Services Plan for unit testing, benchmarking, and deployment

PRACTICE TESTS

Assess your skills with practice tests on CD. You can work through hundreds of questions using multiple testing modes to meet your specific learning needs. You get detailed explanations for right and wrong answers including a customized learning path that describes how and where to focus your studies.

Your training kit includes:





Official self-paced study guide. Practice tests with multiple, customizable testing options and a learning plan based on your results. 200+ practice and review questions. Case scenarios, practice exercises, and best practices. 180-day evaluation version of Microsoft SQL Server 2005 Enterprise Edition. Fully searchable eBook of this guide.

For customers who purchase an ebook version of this title, instructions for downloading the CD files can be found in the ebook.
Introduction xxv
Selecting and Designing SQL Server Services to Support Business Needs
1(28)
Before You Begin
2(1)
Lesson 1: Selecting the Appropriate Services
3(3)
Practice: Selecting the Appropriate Services to Support Business Needs
5(1)
Lesson 2: Evaluating Core, SQL Server Agent, and Database Mail Solutions
6(7)
Transact-SQL Enhancements
6(2)
Considerations for Using CLR Integration
8(1)
Using SQL Server Agent
9(1)
Using Database Mail
10(1)
Practice: Selecting an Appropriate Programming Language
11(2)
Lesson 3: Using Advanced Services
13(7)
SQL Server Web Services
13(1)
Using Service Broker
14(2)
Replication Enhancements
16(1)
Implementing Distributed Transactions
16(2)
Practice: Using Advanced Database Engine Features
18(2)
Lesson 4: Evaluating Other Services
20(7)
Notification Services
20(1)
Reporting Services
21(1)
Analysis Services
22(2)
Integration Services
24(2)
Practice: Using Other Services
26(1)
Case Scenario: Select SQL Server Services to Support Business Needs
27(1)
Chapter Summary
27(2)
Designing a Logical Database
29(28)
Before You Begin
29(2)
Lesson 1: Systematically Approaching Design Stages
31(7)
Key Steps and Best Practices for Data Modeling
32(1)
Object Role Modeling and the Conceptual Model
33(2)
Entity Relationship and the Logical Model
35(2)
Practice: Opening Models
37(1)
Lesson 2: Designing a Normalized Database
38(7)
First Normal Form
38(2)
Second Normal Form
40(1)
Third Normal Form
41(1)
Practice: Normalizing the Database
42(3)
Lesson 3: Optimizing the Database Design by Denormalizing
45(4)
Practice: Denormalizing the Database
47(2)
Lesson 4: Designing the Data Flow Architecture
49(3)
Data Flow for OLTP Applications
49(1)
Data Flow for Business Intelligence Applications
50(2)
Lesson 5: Supertypes and Subtypes
52(4)
Supertypes and Subtypes
52(1)
Modeling Hierarchies
53(1)
Practice: Supertypes, Subtypes, and Hierarchies
54(2)
Case Scenario: Design a Logical Database
56(1)
Chapter Summary
56(1)
Designing a Physical Database
57(42)
Before You Begin
58(1)
Lesson 1: Choosing Column Data Types and Sizes
59(7)
System Data Types
59(5)
Best Practices for Data Types and Sizes
64(1)
Practice: Choosing Appropriate Data Types
65(1)
Lesson 2: Designing User-Defined Data Types
66(8)
T-SQL Aliases (UDDTs)
66(1)
CLR User-Defined Types (UDTs)
66(4)
Best Practices for User-Defined Data Types
70(1)
Practice: Creating User-Defined Data Types
71(3)
Lesson 3: Defining Entities and Entity and Referential Integrity
74(10)
Designing and Creating Entities
74(2)
Entity Integrity
76(1)
Referential Integrity
77(2)
Special Attributes
79(1)
Practice: Defining Entities and Entity and Referential Integrity
80(4)
Lesson 4: Defining Domain Integrity and Business Rules
84(6)
Default Constraints
84(1)
Check Constraints
84(2)
Practice: Implementing Domain Integrity
86(4)
Lesson 5: Creating Programmable Objects to Maintain Integrity
90(6)
DML Triggers
90(3)
Practice: Creating DML Triggers and Testing Data Integrity
93(3)
Case Scenario: Design a Physical Database
96(1)
Chapter Summary
97(2)
Designing a Database for Performance
99(26)
Before You Begin
100(1)
Lesson 1: Optimizing Queries by Creating Indexes
101(4)
The Basics of Optimizing Queries
101(1)
Maintaining Statistics
102(1)
Practice: Selecting Columns to Index
103(2)
Lesson 2: Designing Indexes
105(8)
Clustered and Nonclustered Indexes
105(3)
Creating Indexes
108(1)
Practice: Designing Indexes
109(4)
Lesson 3: Specifying Indexed Views
113(6)
Indexing a Computed Column
113(1)
Indexing a View
114(2)
Practice: Specifying Indexed Views
116(3)
Lesson 4: Partitioning a Table
119(5)
Understanding Table Partitioning
119(2)
Practice: Partitioning a Table
121(3)
Case Scenario: Design a Database for Performance
124(1)
Chapter Summary
124(1)
Using Appropriate Database Technologies and Techniques for Your Application
125(26)
Before You Begin
126(1)
Lesson 1: Using XML Data in Databases
127(6)
XML Data Type Usage
127(1)
XML Indexes
128(1)
Practice: Using XML Data in a Database
129(4)
Lesson 2: Choosing Languages
133(4)
CLR vs. T-SQL
133(1)
CLR and T-SQL vs. Other Languages
134(1)
Practice: Choosing Appropriate Languages
135(2)
Lesson 3: Designing for Scalability
137(9)
Scaling Up
137(3)
Scaling Out
140(2)
Developing Aggregation Strategies
142(1)
Practice: Using Bulk Insert
143(3)
Lesson 4: Designing Interoperability with External Systems
146(4)
Synchronous Methods
146(1)
Asynchronous Methods
147(1)
Practice: Linking to Excel 2007
148(2)
Case Scenario: Implement Database Technologies and Techniques for Your Application
150(1)
Chapter Summary
150(1)
Designing Objects That Retrieve Data
151(34)
Before You Begin
152(1)
Lesson 1: Designing Views
153(12)
Choosing Between the Different Types of Views
153(9)
Practice: Designing Views
162(3)
Lesson 2: Designing Stored Procedures
165(8)
What Type of Stored Procedure Do You Need?
166(1)
What Type of Data Will the Stored Procedure Return?
167(1)
Defining Input, Output, and Optional Parameters for the Stored Procedure
167(2)
Defining the Status Value the Stored Procedure Returns
169(1)
Designing Error Handling Routines
169(1)
Executing Under the Right Security Context
170(1)
Practice: Creating and Modifying a Stored Procedure
171(2)
Lesson 3: Designing User-Defined Functions
173(10)
What Type of UDF Do You Need?
175(4)
What Type of Data Will the UDF Return?
179(1)
Defining Input Parameters for the UDF
180(1)
Designing Error Handling Routines
180(1)
Executing Under the Right Security Context
181(1)
Practice: Designing User-Defined Functions
181(2)
Case Scenario: Designing Objects That Retrieve Data
183(1)
Chapter Summary
184(1)
Designing Objects That Extend Server Functionality
185(40)
Before You Begin
185(2)
Lesson 1: Creating and Designing Stored Procedures
187(17)
Understanding Stored Procedures
187(1)
Creating T-SQL Stored Procedures
187(5)
Changing and Deleting T-SQL Stored Procedures
192(1)
Designing T-SQL Stored Procedures
193(2)
Creating CLR Stored Procedures
195(4)
Practice: Creating a T-SQL Stored Procedure to Add Employees
199(5)
Lesson 2: Designing Scalar User-Defined Functions
204(6)
Creating T-SQL Scalar Functions
204(1)
Creating CLR Scalar Functions
205(1)
UDF Properties
206(1)
Practice: Creating a CLR User-Defined Function to Extract E-Mail
207(3)
Lesson 3: Designing DML and DDL Triggers
210(7)
Creating DML Triggers
210(2)
Creating DDL Triggers
212(2)
Practice: Using a Trigger to Create a Deleted-Rows Table
214(3)
Lesson 4: Designing CLR User-Defined Aggregates
217(6)
Programming User-Defined Aggregates
217(2)
User-Defined Aggregate Attributes
219(1)
Practice: Creating a User-Defined Aggregate
220(3)
Case Scenario: Adding an Audit Trail
223(1)
Chapter Summary
224(1)
Designing a Secure Application Solution
225(98)
Before You Begin
225(1)
Lesson 1: Securing Components of a SQL Server Solution
226(14)
SQL Server Authentication Modes
227(1)
Authorization Strategy
228(2)
Securing HTTP Endpoints
230(1)
CLR Integration Security
230(1)
Guidelines for Replication Security
231(1)
Linked Servers Security
232(1)
SQL Server Agent and DatabaseMail
232(1)
Designing Security for Notification Services
233(1)
Designing Security for Reporting Services
234(1)
Designing Security for Analysis Services
235(2)
Designing Security for Integration Services
237(1)
Practice: Securing a SQL Server Solution
238(2)
Lesson 2: Designing the Database to Enable Auditing and Encryption
240(8)
Considerations for an Auditing Strategy
240(1)
Auditing Events, Techniques, Tools, and Storage
241(3)
Data Protection
244(1)
Data Encryption
244(2)
Practice: Using Event Notifications to Audit DDL Events
246(2)
Case Scenario: Design a Secure Application Solution
248(1)
Chapter Summary
249(52)
Creating a Setup Testing Script
294(1)
Creating a Teardown Testing Script
295(1)
Validating the Testing, Setup, and Teardown Scripts
295(1)
Creating or Setting Up a Test Database
295(1)
Setting Up Testing Data
296(1)
Executing the Unit Test
296(1)
Evaluating the Test Result
297(1)
Practice: Creating a Unit Testing Script and a Testing Database
297(4)
Lesson 2: Designing Tests for Query Performance
301(5)
How to Design a Test
301(2)
Writing a Test to Validate Query Performance
303(1)
Practice: Designing a Testing Script and Setting Performance Goals
304(2)
Lesson 3: Designing Tests for Data Consistency
306(4)
Testing Values of Attributes
306(1)
Validating Foreign Key Constraints
306(1)
Validating Custom Constraints
307(1)
Writing a Test to Validate Data Consistency
307(1)
Practice: Validating Data Consistency in a UDF
308(2)
Lesson 4: Designing Tests for Application Security
310(3)
Validating the Existence of Permissions, Principals, and Roles
310(1)
Validating the Execution Context for Specific Permissions, Principals, and Roles
310(1)
Writing a Test to Validate Application Security
310(1)
Practice: Validating Whether a User Has Been Created
311(2)
Lesson 5: Designing Tests for System Resources Use
313(4)
Setting Performance Goals
313(1)
Using Performance Goals to Evaluate Performance Counters and Metrics
314(1)
Practice: Choosing Performance Counters and Metrics
314(3)
Lesson 6: Designing Tests to Ensure Code Coverage
317(3)
Setting a Goal for Code Coverage
317(1)
Meeting Code-Coverage Test Requirements
317(1)
Writing a Test to Validate Code Coverage
317(2)
Practice: Designing a Test to Ensure Code Coverage
319(1)
Case Scenario: Design a Unit Test Plan for a Database
320(1)
Chapter Summary
321(2)
Creating a Database Benchmarking Strategy
323(32)
Before You Begin
323(1)
Lesson 1: Establishing Performance Objectives and Capacity Planning
324(9)
Establishing Performance Objectives
324(1)
Performance Modeling
325(3)
Capacity Planning
328(2)
Practice: Setting Performance Objectives
330(3)
Lesson 2: Creating a Strategy for Measuring Performance Changes
333(8)
Generating a Representative Baseline
333(1)
Measuring a Baseline
333(1)
Measuring Performance Changes
334(1)
Monitoring the Test Environment
334(1)
Implementing Performance Measuring Techniques
335(3)
Using SQL Server Profiler
338(1)
Practice: Measuring Performance Changes
339(2)
Lesson 3: Creating a Plan for Responding to Performance Changes
341(7)
Setting Goals
341(1)
Determining What Has Changed
341(2)
Determining How Change Affects the System
343(1)
Responding to Performance Changes
343(1)
Issues That Can Affect Performance and Scalability
344(1)
Practice: Responding to Performance Changes
345(3)
Lesson 4: Creating a Plan for Tracking Benchmark Statistics Over Time
348(4)
Setting Goals
348(1)
Continued Testing and Performance Measuring
349(1)
Generating and Documenting Best Practices
350(1)
Practice: Creating a Plan
351(1)
Case Scenario: Create a Performance Baseline and Benchmarking Strategy
352(1)
Chapter Summary
353(2)
Creating a Plan for Deploying a Database
355(30)
Before You Begin
356(1)
Lesson 1: Selecting a Deployment Technique
357(15)
Deploying with the SSMS Copy Database Wizard
357(4)
Customizing the SSIS Package Created by the Copy Database Wizard
361(3)
Deploying with T-SQL Scripts
364(1)
Deploying with the Import and Export Wizard
365(2)
Deploying with SSIS
367(1)
Deploying with the SQLCmd Utility
368(1)
Practice: Detaching and Attaching a Database
369(3)
Lesson 2: Practical Deployment Considerations
372(11)
Deploying Securely
372(4)
Creating an Object-Change Strategy
376(2)
Creating a Data-Change Strategy
378(1)
Creating an Audit Trail
378(2)
Defining Change Control
380(1)
Creating a Project-Management Methodology
380(1)
Practice: Deploying to SQL Server Express by Using Backup and Restore
381(2)
Case Scenario: Deploying a Database
383(1)
Chapter Summary
384(1)
Controlling Changes to Source Code
385(32)
Before You Begin
385(2)
Lesson 1: Managing Source Code Changes
387(10)
SQL Server Management Studio and Source Control
387(2)
Adding the Project to Source Control
389(4)
Working with a Source-Controlled Database Project
393(2)
Practice: Managing Changes to Source Code
395(2)
Lesson 2: Setting File Permissions
397(3)
Visual SourceSafe User Permissions and Rights
397(1)
Folder Permissions
398(1)
Opening Visual SourceSafe-Controlled Projects
398(1)
Optional Practice: Setting Source Control File Permissions
398(2)
Lesson 3: Setting and Retrieving Version Information
400(4)
Practice: Set Version Information
403(1)
Lesson 4: Detecting Differences Between Versions
404(4)
Practice: Detect Version Differences
406(2)
Lesson 5: Encrypting Source Code
408(5)
Practice: Source Code Encryption
412(1)
Lesson 6: Tracking Changes to Groups of Objects
413(1)
Case Scenario: Controlling Changes to Source Code
414(1)
Chapter Summary
415(2)
Designing for Data Distribution
417(26)
Before You Begin
417(2)
Lesson 1: Designing a DatabaseMail Solution for Distributing Data
419(6)
DatabaseMail Architecture
419(1)
Enabling DatabaseMail
420(1)
DatabaseMail Accounts, Profiles, and Security
421(1)
Sending Messages
422(1)
Practice: Sending E-Mail Messages by Using DatabaseMail
422(3)
Lesson 2: Designing SQL Server Agent Alerts
425(5)
Defining Alerts
425(1)
Designing WMI Triggers
426(1)
Defining and Notifying Operators
427(1)
Creating User-Defined Events
428(1)
Practice: Creating a SQL Server Agent Alert
428(2)
Lesson 3: Specifying a Web Services Solution for Distributing Data
430(4)
Creating and Defining SQL Server Web Services
430(1)
SQL Server Web Services Security
431(1)
Guidelines for Using SQL Server Web Services
432(1)
Practice: Creating a SQL Server Web Service
432(2)
Lesson 4: Specifying a Reporting Services Solution for Distributing Data
434(4)
Reporting Services Delivery Options
434(1)
Reporting Services Subscriptions
434(1)
Distributing Data by Using Data-Driven Subscriptions
435(1)
Creating a Data-Driven Subscription
435(2)
Practice: Specifying SSRS Options for Distributing Data
437(1)
Lesson 5: Specifying a Notification Services Solution for Distibuting Data
438(3)
Notification Services Architecture
438(1)
Scale-Out Options
439(1)
Defining Notification Services Applications
440(1)
Practice: Identifying When to Use a Notification Services Solution
440(1)
Case Scenario: Design a Distributed Data Solution
441(1)
Chapter Summary
442(1)
Designing Applications That Support Reporting and Use Reporting Services
443(48)
Before You Begin
444(1)
Lesson 1: Evaluating the Use of Reporting Services and Designing Reports
445(10)
Evaluating Reporting Services Uses
445(4)
Designing Reporting Services Reports
449(2)
Practice: Creating a Report with the Report Wizard
451(4)
Lesson 2: Designing a Snapshot Strategy, Schema, Indexes, and Data Transformations
455(17)
Reporting Services Real-Time Requirements
455(1)
Designing the Snapshot Strategy
456(4)
Designing the Schema
460(3)
Designing Indexes
463(2)
Designing the Data Transformation
465(3)
Practice: Creating a Purchasing Summary Report
468(4)
Lesson 3: Designing Programmatic Interfaces and the Data Access Method for Reporting
472(10)
Querying Tables Directly
472(1)
Using Views to Support Reports
473(3)
Using Stored Procedures
476(2)
Practice: Creating a Row-Filtered Report
478(4)
Lesson 4: Optimizing Reports
482(6)
Report Caching
482(1)
Report Snapshots
483(1)
Specifying Subscription Models
484(1)
Practice: Optimizing Report Performance
485(3)
Case Scenario: Building a Reporting Services Infrastructure for a SharePoint Portal
488(1)
Chapter Summary
489(2)
Developing Applications for Notification Services
491(40)
Before You Begin
492(1)
Lesson 1: Configuring Notification Services Instances and Applications
493(13)
Configuring Notification Services Instances
493(5)
Configuring Notification Services Applications
498(4)
Practice: Configuring Notification Services Applications and Instances
502(4)
Lesson 2: Defining Notification Services Events and Event Providers
506(6)
Defining Event Classes
506(1)
Defining Event Providers
507(2)
Practice: Using Event Providers and Event Classes
509(3)
Lesson 3: Configuring the Notification Services Generator and Distributor
512(4)
Configuring the Notification Services Generator
512(1)
Configuring the Notification Services Distributor
513(1)
Practice: Configuring the Generator and Distributor
514(2)
Lesson 4: Testing the Notification Services Application
516(5)
Creating and Registering a New Instance and Compiling Your Application
516(2)
Exploring Your Instance and Application Objects
518(1)
Removing the Instance and Application
518(1)
Practice: Testing Your Application
519(2)
Lesson 5: Creating Subscriptions
521(5)
Defining the Subscription Class
521(2)
Subscription Management Interfaces
523(1)
Practice: Subscription in Notification Services
524(2)
Lesson 6: Optimizing Notification Services
526(3)
Optimizing Event Data
526(1)
Optimizing Subscriptions
527(1)
Optimizing Notifications
527(1)
Practice: Optimizing Notification Services Solutions
528(1)
Case Scenario: Design a Notification Services Application
529(1)
Chapter Summary
529(2)
Developing Packages for Integration Services
531(42)
Before You Begin
531(2)
Lesson 1: Creating Integration Services Packages
533(20)
What Is a Package?
533(2)
Control Flow
535(5)
Data Flow
540(4)
Practice: Creating an SSIS Package
544(9)
Lesson 2: Debugging and Testing SSIS Packages
553(12)
Running SSIS Packages
553(1)
Debugging SSIS Packages
554(3)
Testing SSIS Packages
557(1)
Practice: Debugging Control Flow and Data Flow
558(7)
Lesson 3: Selecting an Appropriate SSIS Technology or Strategy
565(6)
SSIS ETL Design Patterns
565(4)
SSIS: Beyond ETL
569(2)
Case Scenario: Building an SSIS ETL Infrastructure
571(1)
Chapter Summary
571(2)
Case Scenario Answers 573(10)
Index 583


Dejan Sarka, Adolfo Wiernik, Javier Loria, and Andy Leonard are all SQL Server experts with 60 years combined experience. They work at Solid Quality Mentors where they combine deep technical expertise and real-world implementation experience to provide advanced solutions and training for the Microsoft SQL Server database platform.