Delivering High Quality Databases Using Visual Studio 2022

Delivering High Quality Databases Using Visual Studio 2022 (VS191-2022)

Course Length: 2 days
Delivery Methods: Available as private class only
Course Overview

This two-day, instructor-led course provides students with the knowledge and skills to effectively develop, test, and deliver modern SQL Server databases. Students will experience how to manage changes to a database schema, ensure quality through T-SQL unit testing and static code analysis, and automate the build and deployment of SQL Server and Azure SQL databases.

Who should take this class?
This course is intended for database developers and administrators working with modern versions of SQL Server or Azure SQL. Application developers who are involved with writing and testing T-SQL code and working with test data will also find value.

Course Benefits
  • Describe SQL Server Data Tools (SSDT) and how it can be used
  • Differentiate between SSDT, SSIS, SSAS, and SSRS development
  • Explain agile database development
  • Understand the supported versions of SQL Server and Azure SQL
  • Differentiate between connected vs. disconnected development
  • Use SQL Server Object Explorer (SSOX) for database development
  • Use T-SQL editor, debugger, and IntelliSense for database development
  • Contrast imperative vs. declarative development
  • Describe agile database techniques
  • Create and manage a SQL Server database project
  • Think of schema as source code
  • Compare Solution Explorer and SQL Server Object Explorer
  • Import a database schema
  • Import a data-tier application (.dacpac)
  • Import T-SQL Script
  • Find and resolve cross-database dependencies
  • Reference a database project or .dacpac
  • Understand SSDT's database development lifecycle
  • Use a database project to perform various development tasks
  • Create and configure an Azure DevOps project for SSDT
  • Use Git and Azure Repos to manage schema changes
  • Create and clone a Git repository
  • Commit, pull, push, and sync changes using Visual Studio
  • Compare and synchronize schema changes
  • Create and use a project snapshot (.dacpac)
  • Compare and synchronize data changes
  • Describe SQL Server unit testing principles
  • Create a unit test project in Visual Studio
  • Unit test stored procedures, functions, and triggers
  • Use initialize, pre/post-test, and cleanup scripts to simplify testing
  • Differentiate between T-SQL assertions and test conditions
  • Automatically generate tests and test data
  • Create negative unit tests
  • Use tSQLt for SQL Server unit testing
  • Use static code analysis to find common SQL coding issues
  • Configure, view, and optionally suppress messages analysis messages
  • Refactor SQL database design using SSDT refactoring commands
  • Understand and leverage the refactoring log
  • Build and validate a database project
  • Deploy/publish a database project to SQL Server
  • Use variables and custom scripts when building
  • Use build events and actions when building
  • Understand advanced database project types 
  • Use Azure Pipelines to automate database building, deploying, and testing
  • Configure and use self-hosted pipeline agents for building and releasing
  • Run SQL Server unit tests in a pipeline
  • Practice Continuous Integration (CI)
  • Practice Continuous Delivery (CD)
Course Outline
  1. Agile Database Development
    1. Agile database development overview
    2. Agility challenges and blockers
    3. SQL Server Data Tools (SSDT) overview
    4. Connected vs. disconnected development
    5. Imperative vs. declarative development
    6. Agile database techniques
    7. Hands-on
  2. SQL Server Database Projects
    1. Creating a SQL Server database project
    2. Treating schema as source code
    3. Working with SQL Server Object Explorer
    4. Importing database schema
    5. Importing data-tier applications (.dacpac)
    6. Importing scripts
    7. Managing cross-database dependencies
    8. Referencing a database and .dacpac file
    9. Hands-on
  3. Managing Schema Changes
    1. Azure DevOps overview
    2. Azure Repos overview
    3. Using Git to manage schema changes
    4. Cloning, committing, pushing, and pulling
    5. Comparing schemas and syncing changes
    6. Comparing data and syncing changes
    7. Rolling back changes using Git
    8. Rolling back changes using project snapshots
    9. Hands-on
  4. Assuring a High-Quality Design
    1. Database unit testing principles
    2. Levels of database unit testing
    3. SQL Server unit tests
    4. Database unit test designer
    5. T-SQL assertions vs. test conditions
    6. Using tSQLt for SQL Server unit testing
    7. Static code analysis
    8. Database refactoring tools
    9. Hands-on
  5. Building and Deploying
    1. Building the database project
    2. Using pre-build and post-build events
    3. Including additional build scripts
    4. Using build actions
    5. Using the LocalDB isolated sandbox
    6. Deploying changes to SQL Server
    7. Creating and using publishing profiles
    8. Using pre and post-deployment scripts
    9. Using SQLCMD variables within scripts
    10. Building/deploying composite projects
    11. Building/deploying SQL CLR objects
    12. Azure Pipelines overview
    13. Using an automated build pipeline
    14. Practicing Continuous Integration (CI)
    15. Using an automated release pipeline
    16. Running tests in the release pipeline
    17. Practicing Continuous Delivery (CD)
    18. Hands-on
Class Materials

Each student will receive a comprehensive set of materials, including course notes and all the class examples.

Live Private Class
  • Private Class for your Team
  • Live training
  • Online or On-location
  • Customizable
  • Expert Instructors
Request Proposal