Access article here.

With the new Database Project in the latest version of SQL Server Developer Tools, you can now perform your database development in the same environment as your application development. We introduce the new release.
Jamie Laflen and Barclay Hill

If you are using Visual Studio Database Projects today you will find some improvements in this release including: Simplified project templates, SQL Azure/Denali support, offline/online table designer and much, much more.

Install Juneau now. Installing Juneau will also install the new LocalDB SQL engine which is a must have for any SQL developer.

Find more information here on our MSDN Developer Center.

Communicate with the team and ask questions through our Forum.

Send your feedback in through the SQL Feedback Center on Microsoft Connect.

I have posted little over the last year, but now expect that to change as I am excited to once again be working handful of exciting new technologies.

Those that want more information on Juneau and to participate in the product development feedback program you can join the SQL Server Developer Tools Advisory Program here.

•  Solution and Project Management
• Source Code Control and Configuration Management
• Integrating External Changes with the Project System
• Build and Deployment Automation with Visual Studio Database Projects
• Database Testing and Deployment Verification

For an initial publication I am impressed with the amount of content the team has pulled together.  I expect this guidance will continue to evolve and improved.  If you are looking to for information regarding how to improve your use of the Visual Studio Database tooling I recommend the guide as the best place to start. 

Please check out the guidance and participate in the discussions here: https://vsdatabaseguide.codeplex.com/discussions

Below I have updated the sample to use the manifest file to drive the options for the deployments.  It assumes you are using integrated security so it can also pull the connection string from the manifest file.  The sample basically drives the database project deployment engine from a console app. 

using System;
using System.Diagnostics;
using System.IO;
using Microsoft.Data.Schema;
using Microsoft.Data.Schema.Sql;
using Microsoft.Data.Schema.Extensibility;
using Microsoft.Data.Schema.Build;
using Microsoft.Build.Evaluation;
 
namespace DeployLocalModel
{
    class Program
    {
        static void Main(string[] args)
        {
            string manifestFilePath = null;
            ISchemaDeploymentController sdController = null;
            Project projectManifest = null;
            FileInfo manifestFile = null;
            SchemaDeployment sdEngine = null;
            SchemaDeploymentConstructor sdConstructor = null;
            bool hasDeploymentChanges = false;
            bool pastPredeploymentPayload = false;
 
        try
        {
            manifestFilePath = @".\LocalModel.deploymanifest";
 
            if (args.Length > 0)
            {
                manifestFilePath = args[0];
            }
 
            manifestFile = new FileInfo(manifestFilePath);
            if (!manifestFile.Exists)
                throw new Exception("Manfiest file does not exist!");
            
            //Load manifest into MSBUILD Project so we can pull values from it
            projectManifest = new Project(manifestFile.ToString());
 
            /*Create a extension manager so we can load the SQL100 DSP 
              and utilize its implementation of the deployment engine*/
            ExtensionManager extensionManager = 
                new ExtensionManager(typeof(Sql100DatabaseSchemaProvider).FullName);
            
            // Create the deployment controller
            sdConstructor = 
                extensionManager.DatabaseSchemaProvider.GetServiceConstructor<SchemaDeploymentConstructor>();
 
            //Create a new error manager so we can capture the error messages
            ErrorManager errorManager = new ErrorManager();
 
            /*Attach error manager to the deployment constructor. 
            This will allow us to get errors from the deployment contributor later on */
            sdConstructor.Errors = errorManager;
 
            //Set up the deployment engine constructor of what we plan to deploy
            sdConstructor.Setup(
                new FileInfo(projectManifest.GetPropertyValue("SourceModel")), 
                projectManifest.GetPropertyValue("TargetConnectionString"));
 
            //Create an instance of the deployment engine
            sdEngine = sdConstructor.ConstructService();
 
            //Load manifest so other artifacts and options are considerred
            sdEngine.Configure(projectManifest, manifestFile.Directory);
 
            //Do not deploy to dataabase, yet
            sdEngine.SetDeployToDatabase(false);
            //Execute the engine to create our deployment plan
            sdEngine.Execute();
 
             // Get access to the plan so we call walk through it and later execute it
            DeploymentPlan deploymentPlan = sdEngine.Plan;
 
            #region WalkTheDeploymentPlan
            //Start with the first step in the plan and start iterating through it
            DeploymentStep deploymentStep = deploymentPlan.Head;
            while (deploymentStep != null)
            {
#if DEBUG
                //Send deployment step contents to output window
                Debug.Print("Deploy Step {0} contains:\n\r {1}",
                                deploymentStep.GetType().FullName,
                                deploymentStep.Action());
#endif
                /*Check and see if we are past the predeployment script so were can 
                  determine if there are any incremental deployment changes*/
                if (deploymentStep is EndPreDeploymentScriptStep)
                    pastPredeploymentPayload = true;
 
                if (deploymentStep.Action() != "")
                {
                    /*Test to see if we are deploying any changes, 
                      if not we will short circuit later on.*/
                    if (deploymentStep is DeploymentScriptDomStep && pastPredeploymentPayload)
                    {
                        hasDeploymentChanges = true;
                        break;
                    }
 
                }
                deploymentStep = deploymentStep.Next;
            }
 
            #endregion WalkTheDeploymentPlan
 
            if (hasDeploymentChanges)
            {
                //Create a controller se we can work with the deployment plan
                sdController = sdEngine.CreateController();
 
 
                // Setup our event handler so we can listen to events from deployment engine
                sdController.DeploymentMessage
                    += delegate(object sender, DeploymentContributorEventArgs deployArg)
                    {
                        Console.WriteLine("{0}", deployArg.Message.Message);
                    };
 
                //Deploy the model to the target database using the plan
                sdController.UpdateDatabase(deploymentPlan);
            }
            else
            {
                Console.WriteLine("No deployment changes to make!");
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
        finally
        {
            if (sdController != null)
            {
                sdController.Dispose();
            }
            Console.WriteLine("Execution complete. Strike any key to exit.");
            Console.ReadKey();
        }
    
        }
    }
}

If you want to start out with the sample already coded up you can download it from my SkyDrive.

Thanks Steven!

Here are the links to this new MSDN content:

• Walkthrough: Define a Custom Workflow to Deploy a Database from Team Foundation Build
• How to: Deploy Changes using Team Foundation Build

Essentially what the sample contributor does is walks through the deployment plan and creates an additional deployment script with a _lite.sql extension that already has the SQLCMD variables preprocessed and contains only the body of the deployment script.  This can be handy if integrating deployment scripts into other processes or APIs where SQLCMD is not support or statement execution is limited to only the immediate database.  For example, you internet hosting service only allows you to submit a SQL script through their deployment tool and the script can only execute in the context of your user database. This additional _lite.sql  script is not executed against the target. It is simply produced in addition to the original deployment script.

The following is the implementation of our Lite Script Deployment Plan Executor.  You may want to customize this adding or removing additional deployment steps from the new _lite.sql script. To use the sample, download the sample from my SkyDrive and build it. You will then need to register the extension as you do the other samples on MSDN. This sample is already keyed using the key in the project. Simply build the project and move LiteScriptContributor.dll, LiteScriptContributor.pdb, and LiteScriptContributor.Extensions.xml to your %Program Files%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\ directory. The next time you load Visual Studio 2010 the contributor will load and start producing the additional script when deployed.

Special thanks to Jamie Laflen for providing the sample SQL Managed Batch Parser Wrapper.

Here is what that looks like in the output window when deploying your project:

------ Build started: Project: MyDatabase, Configuration: Debug Any CPU ------

    Loading project files...

    Building the project model and resolving object interdependencies...

    Validating the project model...

    Writing model to MyDatabase.dbschema...

  MyDatabase -> C:\Work\Demo\MyDatabase\MyDatabase\sql\debug\MyDatabase.dbschema

------ Deploy started: Project: MyDatabase, Configuration: Debug Any CPU ------

    Lite Deployment SqlCmd substituted script generated to:

C:\Work\Demo\MyDatabase\MyDatabase\sql\debug\MyDatabase_lite.sql

    Deployment script generated to:

C:\Work\Demo\MyDatabase\MyDatabase\sql\debug\MyDatabase.sql

    The deployment script was generated, but was not deployed. You can change the deploy action on the Deploy tab of the project properties.

========== Build: 1 succeeded or up-to-date, 0 failed, 0 skipped ==========

========== Deploy: 1 succeeded, 0 failed, 0 skipped ==========

LiteScriptContributor.cs

using System;

using System.Collections.Generic;

using System.Text;

using Microsoft.Data.Schema.Build;

using Microsoft.Data.Schema.Extensibility;

using Microsoft.Data.Schema.Sql;

using System.IO;

using System.Globalization;

using System.Diagnostics;

using ManagedBatchParser;

namespace LiteScriptContributor

{

    /// <summary>

    /// This deployment contributor generates a deployment script that contains

    /// only the body of the deployment script with the SQLCMD variables pre-processed .

    /// </summary>

    [DatabaseSchemaProviderCompatibility(typeof(SqlDatabaseSchemaProvider))]

    class LiteScriptContributor : DeploymentPlanExecutor

    {

        protected override void OnExecute(DeploymentPlanContributorContext context)

        {

            string scriptName = null;

            string scriptFullPath = null;

            string parserScript = null;

            StreamWriter sw = null;

            BatchParserWrapper parser = null;

            bool writeLiteScript = false;

            try

            {

                scriptName = string.Format(CultureInfo.CurrentCulture, "{0}_lite.sql", context.Options.TargetDatabaseName);

                if (string.IsNullOrEmpty(context.DeploymentScriptPath))

                {

                    // Default script to current directory

                    scriptFullPath = Path.Combine(Environment.CurrentDirectory, scriptName);

                }

                else

                {

                    scriptFullPath = Path.Combine(Path.GetDirectoryName(context.DeploymentScriptPath), scriptName);

                }

                //Open a file to write on new deployment script to

                sw = new StreamWriter(scriptFullPath, false, Encoding.UTF8);

                //Create an instance of our managed batch parser wrapper the we will use later on

                parser = new BatchParserWrapper();

                //Start with the top of the deployment plan, the head step.

                DeploymentStep currentStep = context.PlanHandle.Head;

                while (currentStep != null)

                {

                    /*For our Lite Script we only care about what is between the pre and post

                     *deployment steps in the deployment plan*/

                    if (currentStep is BeginPreDeploymentScriptStep)

                    {

                        writeLiteScript = true;

                    }

                    else

                    {

                        if (currentStep is EndPostDeploymentScriptStep)

                        {

                            writeLiteScript = false;

                        }

                    }

                    //Get T-SQL from deployment step and process the SQLCMD vars

                    string sqlcmdScript = currentStep.Action();

                    parserScript = parser.ProcessSqlCmdScript(sqlcmdScript);

                    //Write out the deployment step to our new file if it meets our criteria

                    if (writeLiteScript)

                    {

                        if (string.IsNullOrEmpty(sqlcmdScript) == false)

                        {

                            sw.Write(parserScript);

                        }

                    }

                    currentStep = currentStep.Next;

                }

                //Send a message back to the deployment engine that will be displayed in the VS output window

                string scriptCompleteMsg =

                    string.Format(CultureInfo.CurrentCulture,

                    "Lite Deployment SqlCmd substituted script generated to:{0}{1}",

                    Environment.NewLine, scriptFullPath);

                SqlServerError scriptCompleteError =

                    new SqlServerError(scriptCompleteMsg,

                                        string.Empty,

                                        Microsoft.Data.Schema.ErrorSeverity.Message);

                base.PublishMessage(scriptCompleteError);

            }

            catch (Exception ex)

            {

                Debug.Write(ex.ToString());

                throw;

            }

            finally

            {

                if (sw != null)

                {

                    sw.Dispose();

                }

                if (parser != null)

                {

                    parser.Dispose();

                }

            }

        }

    }

}

If you want to start out with the sample already coded up you can download it from my SkyDrive.

For those who have used the old .dbp projects and have these in their solutions your .dbp projects will be upgraded to .dbproj projects when you upgrade the solution to 2010.  If you need help getting started working with the .dbproj project you can find the root node of the product documentation here on MSDN.

Additionally, Deborah Kurata, a Visual Basic MVP, has recently posted a series that provides a gentle introduction into the Offline Database Project environment. You can check them out below.

·         Requiem to the VS 2003/2005/2008 Database Project

·         VS 2010 Database Project: An Introduction

·         VS 2010 Database Project: Using an Existing Database

·         VS 2010 Database Project: Adding Tables

·         VS 2010 Database Project: Building and Deployment

·         VS 2010 Database Project: Adding Stored Procedures

There are 3 new areas of the API now public that you can code against and influence the database deployment engine’s behavior or extend it in some fashion. 

Database Deployment Contributors

·         Plan Modifiers - Deployment Plan Modifiers allow the developer to modify the deployment plan before execution. Jamie has a good sample on MSDN which makes scripts produced by the database project re-runnable.

·         Plan Executors - Deployment Plan Executors provide the developer read only access to the deployment to process the deployment plan in some way.  Jamie also has a good sample on MSDN about how to create new artifacts to analyze a deployment plan.

Database Deployment Engine API

·         The Deployment API gives you low-level access to the deployment engine. VSDBCMD is only a shell which leverages the deployment engine and provides simplified access to the deployment engines knobs and buttons.

Here is sample code for using the deployment engine to deploy a local model on disk.  You can see how simple it is to load the model up and then walkthrough the deployment plan.  You can analyze the deployment plan and add and remove steps if you like. You can register customer loggers or even integrate it even tighter with your own deployment frameworks.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Data.SqlClient;

using System.Diagnostics;

using System.IO;

using Microsoft.Data.Schema;

using Microsoft.Data.Schema.Sql;

using Microsoft.Data.Schema.Extensibility;

using Microsoft.Data.Schema.Build;

using Microsoft.Data.Schema.SchemaModel;

using Microsoft.Data.Schema.Sql.SchemaModel;

namespace DeployLocalModel

{

    class Program

    {

        static void Main(string[] args)

        {

            const string conxString

                = @"Server=.\SQLEXPRESS;Integrated Security=true;Pooling=false";

            const string modelFilePath

                = @"..\..\..\LocalModel\sql\debug\LocalModel.dbschema";

            const string targetDatabaseName = @"CarDealership";

            ISchemaDeploymentController schemaDeploymentController = null;

            bool hasChanges = false;

        try

        {

            //Create a new error manager so we can capture the error messages

            ErrorManager errorManager = new ErrorManager();

            /*Create a extension manager so we can load the SQL100 DSP and

            utilize its implementation of the deployment engine*/

            ExtensionManager extensionManager =

                new ExtensionManager(typeof(Sql100DatabaseSchemaProvider).FullName);

            // Create the deployment controller

            SchemaDeploymentConstructor schemaDeploymentConstructor =

                extensionManager.DatabaseSchemaProvider

                .GetServiceConstructor<SchemaDeploymentConstructor>();

            schemaDeploymentConstructor.Setup(new FileInfo(modelFilePath), conxString);

            schemaDeploymentConstructor.Errors = errorManager;

            SchemaDeployment schemaDeployment

                = schemaDeploymentConstructor.ConstructService();

            //Set deployment controller options

            schemaDeployment.Options.TargetDatabaseName = targetDatabaseName;

            //Create a controller becase we will be working with a deployment plan

            schemaDeploymentController = schemaDeployment.CreateController();

            // Setup our event handler so we can listen to events from deployment engine

            schemaDeploymentController.DeploymentMessage

                += delegate(object sender, DeploymentContributorEventArgs deployArg)

            {             

                Console.WriteLine("{0}", deployArg.Message.Message);

            };

            // Get access to the plan so we call walk through it

            DeploymentPlan deploymentPlan = schemaDeploymentController.CreatePlan();

            DeploymentStep deploymentStep = deploymentPlan.Head;

            while (deploymentStep != null)

            {

                if (deploymentStep.Action() != "")

                {

                    //Send deployment step contents to output window

                    Debug.Print("Deploy Step {0} contains:\n\r {1}",

                                    deploymentStep.GetType().FullName,

                                    deploymentStep.Action());

                    /*Test to see if we are deploying any changes,

                    if not we will short circuit later on.*/

                    if (deploymentStep is DeploymentScriptDomStep){

                        hasChanges = true;

                        break;

                    }

                }

                deploymentStep = deploymentStep.Next;

            }

            if (hasChanges)

            {

                //Deploy the model to the target database using the plan

                schemaDeploymentController.UpdateDatabase(deploymentPlan);

            }

            else

            {

                Console.WriteLine("No deployment changes to make!");

            }

        }

        catch (Exception e)

        {

            Console.WriteLine(e.Message);

        }

        finally

        {

            if (schemaDeploymentController != null)

            {

                schemaDeploymentController.Dispose();

            }

            Console.WriteLine("Execution complete. Strike any key to exit.");

            Console.ReadKey();

        }

        }

    }

}

If you want to start out with the sample already coded up you can download it from my SkyDrive.