Querying Microsoft SQL Server 2012/2014

Create database objects (2025%)

Create and alter tables using T-SQL syntax (simple statements)

Create tables without using the built in tools; ALTER; DROP; ALTER
COLUMN; CREATE

Create and alter views (simple statements)

Create indexed views; create views without using the built in tools;
CREATE, ALTER, DROP

Design views

Ensure code non regression by keeping consistent signature for

procedure, views and function (interfaces); security implications

Create and modify constraints (simple statements)

Create constraints on tables; define constraints; unique constraints;

default constraints; primary and foreign key constraints

Create and alter DML triggers

Inserted and deleted tables; nested triggers; types of triggers;

update functions; handle multiple rows in a session; performance
implications of triggers
Preparation resources
Tables
Views
table_constraint (Transact-SQL)
Work with data (2530%)
Query data by using SELECT statements

Use the ranking function to select top(X) rows for multiple

categories in a single query; write and perform queries efficiently
using the new (SQL 2005/8->) code items such as synonyms and
joins (except, intersect); implement logic which uses dynamic SQL
and system metadata; write efficient, technically complex SQL
queries, including all types of joins versus the use of derived tables;
determine what code may or may not execute based on the tables
provided; given a table with constraints, determine which statement
set would load a table; use and understand different data access
technologies; case versus isnull versus coalesce

Implement sub-queries
 Identify problematic elements in query plans; pivot and unpivot;
apply operator; cte statement; with statement

Implement data types

Use appropriate data; understand the uses and limitations of each

data type; impact of GUID (newid, newsequentialid) on database
performance, when to use what data type for columns

Implement aggregate queries

New analytic functions; grouping sets; spatial aggregates; apply

ranking functions

Query and manage XML data

Understand XML datatypes and their schemas and interop w/,

limitations and restrictions; implement XML schemas and handling of
XML data; XML data: how to handle it in SQL Server and when and
when not to use it, including XML namespaces; import and export
XML; XML indexing
Preparation resources
SELECT (Transact-SQL)
INTO clause (Transact-SQL)
FROM (Transact-SQL)
Modify data (2025%)
Create and alter stored procedures (simple statements)

Write a stored procedure to meet a given set of requirements;

branching logic; create stored procedures and other programmatic
objects; techniques for developing stored procedures; different types
of storeproc result; create stored procedure for data access layer;
program stored procedures, triggers, functions with T-SQL

Modify data by using INSERT, UPDATE and DELETE statements

Given a set of code with defaults, constraints and triggers,

determine the output of a set of DDL; know which SQL statements
are best to solve common requirements; use output statement

Combine datasets

Difference between UNION and UNION all; case versus isnull versus
coalesce; modify data by using MERGE statements

Work with functions

 Understand deterministic, non-deterministic functions; scalar and
table values; apply built-in scalar functions; create and alter user-
defined functions (UDFs)
Preparation resources
CREATE PROCEDURE (Transact-SQL)
ALTER PROCEDURE (Transact-SQL)
INSERT (Transact-SQL)
Troubleshoot and optimise (2530%)
Optimise queries

Understand statistics; read query plans; plan guides; DMVs; hints;

statistics IO; dynamic vs. parameterised queries; describe the
different join types (HASH, MERGE, LOOP) and describe the scenarios
they would be used in

Manage transactions

Mark a transaction; understand begin tran, commit and rollback;

implicit vs explicit transactions; isolation levels; scope and type of
locks; trancount

Evaluate the use of row-based operations vs. set-based operations

When to use cursors; impact of scalar UDFs; combine multiple DML

operations

Implement error handling

Implement try/catch/throw; use set-based rather than row-based

logic; transaction management
Preparation resources
Transaction statements (Transact-SQL)
SET TRANSACTION ISOLATION LEVEL (Transact-SQL)
Cursors

Implementing Data Models and Reports

with Microsoft SQL Server

Build an analysis services multidimensional database (35-40%)

Design dimensions and measures
 Given a requirement, identify the dimension/measure group
relationship that should be selected; design patterns for representing
business facts and dimensions (many-to-many relationships); design
dimensions to support multiple related measure groups (many
related fact tables); handle degenerate dimensions in a cube;
identify the attributes for dimensions; identify the measures;
aggregation behaviour for the measures; build hierarchies; define
granularity of dimension relationships

Implement and configure dimensions in a cube

Translations, define attribute relationships, implement hierarchies,

implement SQL Server Analysis Services (SSAS) dimensions and
cubes, create the Attribute Relationships that should be made for a
given set of attributes in a dimension, develop new custom attributes
on dimensions, detect possible design flaws in attribute
relationships, implement time dimensions in cubes, manage SSAS
parent-child dimensions, dimension type

Design a schema to support cube architecture

Multidimensional modelling starting from a star schema, relational

modelling for a data source view, choose or create a topology,
identify the appropriate data types with correct precision and size

Create and configure measures

Logically group measures and configure Measure Group Properties,

select appropriate aggregation functions, format measures, design
the measure group for the correct granularity

Implement a cube

Use SQL Server Data Tools - Business Intelligence (SSDT-BI) to build

the cube; use SSDT-BI to do non-additive or semi-additive measures
in a cube, define measures, specify perspectives, define translations,
define dimension usage, define cube-specific dimension properties,
define measure groups, implement reference dimensions, implement
many-to-many relationships, implement fact relationships,
implement role-playing relationships, create and manage linked
measure groups and linked dimensions, create actions

Create Multidimensional Expressions (MDX) and Data Analysis Expressions

(DAX) queries

Identify the structures of MDX and the common functions (tuples,

sets, TopCount, SCOPE and more); identify which MDX statement
would return the required result; implement a custom MDX or logical
solution for a pre-prepared case task; identify the structure of DAX
 and common functions, including CALCULATE, EVALUATE and FILTER;
identify which DAX query would return the required result

Implement custom logic in a data model

Define key performance indicators (KPIs); define calculated

members; create relative measures (growth, YoY, same period last
year), percentage of total using MDX; named sets; add Time
Intelligence; implement ranking and percentile; define MDX script to
import partial PowerPivot model

Implement storage design in a multidimensional model

Create aggregations, create partitions, storage modes, define

proactive caching, manage write-back partitions, implement linked
cubes, implement distributed cubes

Select an appropriate model for data analysis

Select Tabular versus Multidimensional based on scalability needs,

traditional hierarchical, data volume; select appropriate
organisational BI, such as corporate BI, and team and personal BI
needs and data status
Preparation resources
Dimension relationships
Defining dimension granularity within a measure group
Linked measure groups
Manage, maintain and troubleshoot an SQL Server Analysis Services (SSAS)
database (15-20%)
Analyse data model performance

Identify performance consequences of data source view design,

optimise performance by changing the design of the cube or
dimension, analyse and optimise performances of an MDX/DAX
query, optimise queries for huge data sets, optimise MDX in the
calculations, performance monitor counters, select appropriate
Dynamic Management Views for Analysis Services, analyse and
define performance counters, monitor growth of the cache, define
and view logging options

Process data models

Define processing of tables or partitions for tabular and

multidimensional models; define processing of databases, cubes and
dimensions for multidimensional models; select full processing
versus incremental processing; define remote processing; define lazy
aggregations; automate with Analysis Management Objects (AMO) or
 XML for Analysis (XMLA); process and manage partitions by using
PowerShell

Troubleshoot data analysis issues

Use SQL Profiler; troubleshoot duplicate key dimension processing

errors; error logs and event viewer logs of SSAS, mismatch of data:
incorrect relationships or aggregations; dynamic security issues;
validate logic and calculations

Deploy SSAS databases

Deployment Wizard, implement SSDT-BI, deploy SSMS; test solution

post deployment, decide whether or not to process, test different
roles

Install and maintain an SSAS instance

Install SSAS; install development tools; identify development and

production installation considerations; upgrade SSAS instance; define
data file and program file location; plan for Administrator accounts;
define server and database-level security; support scale-out read-
only; update SSAS (service packs); install and maintain each
instance type of Analysis Services, including PowerPivot; restore and
import PowerPivot; back up and restore by using PowerShell
Preparation resources
Multidimensional model object processing
Performance counters (SSAS)
Build a tabular data model (15-20%)
Configure permissions and roles in a tabular model

Configure server roles, configure SSAS database roles, implement

dynamic security (custom security approaches), role-based access,
test security permissions, implement cell-level permissions

Implement a tabular data model

Define tables, import data, define calculated columns, define

relationships, define hierarchies and perspectives, manage visibility
of columns and tables, embed links, optimise BISM for Power View,
mark a date table, sort a column by another column

Implement business logic in a tabular data model

Implement measures and KPIs, implement Data Analysis

Expressions (DAX), define relationship navigation, implement time
intelligence, implement context modification

Implement data access for a tabular data model

 Manage partitions, processing, select xVelocity versus DirectQuery
for data access
Preparation resources
Using DirectQuery in the tabular BI Semantic Model
Roles (SSAS tabular)
Hierarchies (SSAS tabular)
Build a report with SQL Server Reporting Services (SSRS) (25-30%)
Design a report

Select report components (crosstab report, Tablix, design chart,

data visualisation components), design report templates (Report
Definition Language), identify the data source and parameters;
design a grouping structure; drilldown reports, drillthrough reports;
determine if any expressions are required to display data that is not
coming directly from the data source

Implement a report layout

Formatting; apply conditional formatting; page configuration;

implement headers and footers; implement matrices, table, chart,
images, list, indicators, maps and groupings in reports; use Report
Builder to implement a report layout; create a range of reports using
different data regions; define custom fields (implementing different
parts of the report); implement collections (global collections); define
expressions; implement data visualisation components; identify
report parts; implement group variables and report variables; design
for multiple delivery extension formats

Configure authentication and authorisation for a reporting solution

Configure server-level and item-level role-based security, configure

reporting service security (setup or addition of role), authenticate
against data source, store credential information, describe Report
Server security architecture and site-level security, create system-
level roles, item-level security, create a new role assignment, assign
Windows users to roles, secure reports using roles, configure
SharePoint groups and permissions, define varying content for
different role memberships

Implement interactivity in a report

Drilldown; drillthrough; interactive sorting; parameters: (databound

parameters, multi-value parameters); create dynamic reports in
SSRS using parameters; implement show/hide property; actions
(jump to report); filters; parameter list; fixed headers; document
map, embedded HTML

Troubleshoot reporting services issues

 Query the ReportServer database; view Reporting Services log files;
use Windows Reliability and Performance monitor data for
troubleshooting; use the ReportServer: define service and web
service objects; monitor for long-running reports, rendering and
connectivity issues; use SQL Profiler; perform data reconciliation for
incorrect relationships or aggregations; detect dynamic security
issues; validate logic and calculations

Manage a report environment

Manage subscriptions and subscription settings; define data-driven

subscriptions; manage data sources; integrate SharePoint Server;
define email delivery settings; manage the number of snapshots;
manage schedules, running jobs and report server logs; manage
report server databases; manage the encryption keys; set up the
execution log reporting; review the reports; configure site-level
settings; design report lifecycle; automate management of reporting
services; create a report organisation structure; install and configure
reporting services; deploy custom assemblies

Configure report data sources and datasets

Select appropriate query types (stored procedure versus table

versus text only); configure parameterised connection strings
(dynamic connection strings); define filter location (dataset versus
query); configure data source options, for example, extract and
connect to multiple data sources; shared and embedded data
sources and datasets; use custom expressions in data sources;
connect to Microsoft Azure SQL database; implement DAX and MDX
queries to retrieve appropriate data sets; work with non-relational
data sources, such as XML or SharePoint lists
Preparation resources
Tablix data region (Report Builder and SSRS)
Built-in Globals and Users references (Report Builder and SSRS)
Create data-driven subscription page (Report Manager)

Programming in C#

Manage program flow (2530%)

Implement multithreading and asynchronous processing

Use the Task Parallel library (ParallelFor, Plinq, Tasks); create

continuation tasks; spawn threads by using ThreadPool; unblock the
 UI; use async and await keywords; manage data by using concurrent
collections

Manage multithreading

Synchronise resources; implement locking; cancel a long-running

task; implement thread-safe methods to handle race conditions

Implement program flow

Iterate across collection and array items; program decisions by

using switch statements, if/then, and operators; evaluate
expressions

Create and implement events and callbacks

Create event handlers; subscribe to and unsubscribe from events;

use built-in delegate types to create events; create delegates;
lambda expressions; anonymous methods

Implement exception handling

Handle exception types (SQL exceptions, network exceptions,

communication exceptions, network timeout exceptions); catch
typed vs. base exceptions; implement try-catch-finally blocks; throw
exceptions; determine when to rethrow vs. throw; create custom
exceptions
Preparation resources
Asynchronous programming with Async and Await (C# and Visual Basic)
Threading (C# and Visual Basic)
Selection statements (C# reference)
Create and use types (2530%)
Create types

Create value types (structs, enum), reference types, generic types,

constructors, static variables, methods, classes, extension methods,
optional and named parameters, and indexed properties; create
overloaded and overridden methods

Consume types

Box or unbox to convert between value types; cast types; convert

types; handle dynamic types; ensure interoperability with
unmanaged code, for example, dynamic keyword

Enforce encapsulation
 Enforce encapsulation by using properties, by using accessors
(public, private, protected) and by using explicit interface
implementation

Create and implement a class hierarchy

Design and implement an interface; inherit from a base class;

create and implement classes based on the IComparable,
IEnumerable, IDisposable and IUnknown interfaces

Find, execute and create types at runtime by using reflection

Create and apply attributes; read attributes; generate code at

runtime by using CodeDom and lambda expressions; use types from
the System.Reflection namespace (Assembly, PropertyInfo,
MethodInfo, Type)

Manage the object lifecycle

Manage unmanaged resources; implement IDisposable, including

interaction with finalisation; manage IDisposable by using the Using
statement; manage finalisation and garbage collection

Manipulate strings

Manipulate strings by using the StringBuilder, StringWriter and

StringReader classes; search strings; enumerate string methods;
format strings
Preparation resources
Types (C# programming guide)
Classes and structs (C# programming guide)
Object-oriented programming (C# and Visual Basic)
Debug applications and implement security (2530%)
Validate application input

Validate JSON data; data collection types; manage data integrity;

evaluate a regular expression to validate the input format; use built-
in functions to validate data type and content out of scope: writing
regular expressions

Perform symmetric and asymmetric encryption

Choose an appropriate encryption algorithm; manage and create

certificates; implement key management; implement the
System.Security namespace; hashing data; encrypt streams

Manage assemblies
 Version assemblies; sign assemblies using strong names; implement
side-by-side hosting; put an assembly in the global assembly cache;
create a WinMD assembly

Debug an application

Create and manage compiler directives; choose an appropriate

build type; manage programming database files and symbols

Implement diagnostics in an application

Implement logging and tracing; profiling applications; create and

monitor performance counters; write to the event log
Preparation resources
Validating data
.NET Framework regular expressions
Implement data access (2530%)
Perform I/O operations

Read and write files and streams; read and write from the network
by using classes in the System.Net namespace; implement
asynchronous I/O operations

Consume data

Retrieve data from a database; update data in a database; consume

JSON and XML data; retrieve data by using web services

Query and manipulate data and objects by using LINQ

Query data by using operators (projection, join, group, take, skip,

aggregate); create method-based LINQ queries; query data by using
query comprehension syntax; select data by using anonymous types;
force execution of a query; read, filter, create and modify data
structures by using LINQ to XML

Serialise and deserialise data

Serialise and deserialise data by using binary serialisation, custom

serialisation, XML Serializer, JSON Serializer and Data Contract
Serializer

Store data in and retrieve data from collections

Store and retrieve data by using dictionaries, arrays, lists, sets and
queues; choose a collection type; initialise a collection; add and
remove items from a collection; use typed vs. non-typed collections;
implement custom collections; implement collection interfaces
 Preparation resources
File system and the registry (C# programming guide)
Connecting to data in Visual Studio
Editing data in your application