演练：扩展数据库项目部署以修改部署计划

  • 项目

可以创建部署参与者，以在部署数据库项目时执行自定义操作。 可以创建 DeploymentPlanModifier 或 DeploymentPlanExecutor。 使用 DeploymentPlanModifier 可在执行计划前更改计划，使用 DeploymentPlanExecutor 可在执行计划期间执行操作。 在本演练中，您会创建一个名为 SqlRestartableScriptContributor 的 DeploymentPlanModifier，它将 IF 语句添加到部署脚本中的批处理代码，从而使脚本在执行过程中发生错误时可以反复运行，直到这些语句完成。

在本演练中，您将完成以下主要任务：

  • 创建 DeploymentPlanModifier 类型的部署参与者

  • 安装部署参与者

  • 测试部署参与者

系统必备

您需要以下组件来完成本演练：

  • 在计算机上安装 Visual Studio 2010 高级专业版 或 Visual Studio 2010 旗舰版。

  • 包含数据库对象的数据库项目

  • 可以向其部署数据库项目的 SQL Server 实例

提示

本演练专供已熟悉 Visual Studio 数据库功能的用户使用。 同时，您还应熟悉基本的 Visual Studio 概念，例如如何创建类库以及如何使用代码编辑器向类添加代码。

创建部署参与者

若要创建部署参与者，必须执行以下任务：

  • 创建类库项目并添加所需引用

  • 定义一个名为 SqlRestartableScriptContributor 的类，该类继承自 DeploymentPlanModifier

  • 重写 OnExecute 方法

  • 添加私有帮助器方法

  • 生成结果程序集

创建类库项目

  1. 创建一个名为 MyOtherDeploymentContributor 的 Visual C# 或 Visual Basic 类库项目。

  2. 在解决方案资源管理器中，右击该项目，然后单击**“添加引用”**。

  3. 单击**“.NET”**选项卡。

  4. 突出显示**“Microsoft.Data.Schema”、“Microsoft.Data.Schema.Sql”、“Microsoft.Data.Schema.ScriptDom”和“Microsoft.Data.Schema.ScriptDom.Sql”项，然后单击“确定”**。

    接下来，开始向类中添加代码。

定义 SqlRestartableScriptContributor 类

  1. 在代码编辑器中，更新 class1.cs 文件以匹配以下 using 语句：

    using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Data.Schema.Build;
using Microsoft.Data.Schema.ScriptDom.Sql;
using Microsoft.Data.Schema.SchemaModel;
using System.Globalization;
using Microsoft.Data.Schema.ScriptDom;
using Microsoft.Data.Schema.Extensibility;
using Microsoft.Data.Schema.Sql;
using Microsoft.Data.Schema.Sql.Build;
using Microsoft.Data.Schema.Sql.SchemaModel;

    Imports System
Imports System.Collections.Generic
Imports System.Text
Imports Microsoft.Data.Schema.Build
Imports Microsoft.Data.Schema.ScriptDom.Sql
Imports Microsoft.Data.Schema.SchemaModel
Imports System.Globalization
Imports Microsoft.Data.Schema.ScriptDom
Imports Microsoft.Data.Schema.Extensibility
Imports Microsoft.Data.Schema.Sql
Imports Microsoft.Data.Schema.Sql.Build
Imports Microsoft.Data.Schema.Sql.SchemaModel

  2. 更新类定义以匹配下面的示例：

            /// <summary>
    /// This deployment contributor modifies a deployment plan by adding if statements
    /// to the existing batches in order to make a deployment script able to be rerun to completion
    /// if an error is encountered during execution
    /// </summary>
    [DatabaseSchemaProviderCompatibility(typeof(SqlDatabaseSchemaProvider))]
    class SqlRestartableScriptContributor : DeploymentPlanModifier
    {
    }

    ''' <summary> 
''' This deployment contributor modifies a deployment plan by adding if statements 
''' to the existing batches in order to make a deployment script able to be rerun to completion 
''' if an error is encountered during execution 
''' </summary> 
<DatabaseSchemaProviderCompatibility(GetType(SqlDatabaseSchemaProvider))> _
Class SqlRestartableScriptContributor
    Inherits DeploymentPlanModifier
End Class

    现在您已定义了从 DeploymentPlanModifier 继承的生成参与者。 您使用 DatabaseSchemaProviderCompatibilityAttribute 特性指示此参与者与从 SqlDatabaseSchemaProvider 继承的任何数据库架构提供程序都兼容。

  3. 添加以下成员声明：

            private const string BatchIdColumnName = "BatchId";
        private const string DescriptionColumnName = "Description";

        private const string CompletedBatchesVariableName = "CompletedBatches";
        private const string CompletedBatchesVariable = "$(CompletedBatches)";
        private const string CompletedBatchesSqlCmd = @":setvar " + CompletedBatchesVariableName + " __completedBatches_{0}_{1}";
        private const string TotalBatchCountSqlCmd = @":setvar TotalBatchCount {0}";
        private const string CreateCompletedBatchesTable = @"
if OBJECT_ID(N'tempdb.dbo." + CompletedBatchesVariable + @"', N'U') is null
begin
use tempdb
create table [dbo].[$(CompletedBatches)]
(
BatchId int primary key,
Description nvarchar(300)
)
use [$(DatabaseName)]
end
";
        private const string DropCompletedBatchesTable = @"drop table [tempdb].[dbo].[" + CompletedBatchesVariable + "]";

        Private Const BatchIdColumnName As String = "BatchId"
    Private Const DescriptionColumnName As String = "Description"

    Private Const CompletedBatchesVariableName As String = "CompletedBatches"
    Private Const CompletedBatchesVariable As String = "$(CompletedBatches)"
    Private Const CompletedBatchesSqlCmd As String = ":setvar " & CompletedBatchesVariableName & " __completedBatches_{0}_{1}"
    Private Const TotalBatchCountSqlCmd As String = ":setvar TotalBatchCount {0}"
    Private Const CreateCompletedBatchesTable As String = vbCr & vbLf & "if OBJECT_ID(N'tempdb.dbo." & CompletedBatchesVariable & "', N'U') is null" & vbCr & vbLf & "begin" & vbCr & vbLf & vbTab & "use tempdb" & vbTab & vbCr & vbLf & vbTab & "create table [dbo].[$(CompletedBatches)]" & vbCr & vbLf & vbTab & "(" & vbCr & vbLf & vbTab & vbTab & "BatchId int primary key," & vbCr & vbLf & vbTab & vbTab & "Description nvarchar(300)" & vbCr & vbLf & vbTab & ")" & vbCr & vbLf & vbTab & "use [$(DatabaseName)]" & vbTab & vbCr & vbLf & "end" & vbCr & vbLf
    Private Const DropCompletedBatchesTable As String = "drop table [tempdb].[dbo].[" & CompletedBatchesVariable & "]"

    接下来，重写 OnExecute 方法，以添加要在部署数据库项目时运行的代码。

重写 OnExecute

  1. 将下面的方法添加到您的 SqlRestartableScriptContributor 类：

            /// <summary>
        /// You override the OnExecute method to do the real work of the contributor.
        /// </summary>
        /// <param name="context"></param>
        protected override void OnExecute(DeploymentPlanContributorContext context)
        {
             // Replace this with the method body
        }

        ''' <summary> 
    ''' You override the OnExecute method to do the real work of the contributor. 
    ''' </summary> 
    ''' <param name="context"></param> 
    Protected Overloads Overrides Sub OnExecute(ByVal context As DeploymentPlanContributorContext)
        ' Replace this with the method body
    End Sub

    重写来自基类 DeploymentPlanContributor（该类是 DeploymentPlanModifier 和 DeploymentPlanExecutor 的基类）的 OnExecute 方法。 会向 OnExecute 方法传递一个 DeploymentPlanContributorContext 对象，该对象提供对任何指定参数、源和目标数据库模型、生成属性和扩展文件的访问。 在此示例中，我们获取部署计划和目标数据库名称。

  2. 现在将主体的开头添加到 OnExecute 方法：

            // Obtain the first step in the Plan from the provided context
        DeploymentStep nextStep = context.PlanHandle.Head;
        int batchId = 0;
        BeginPreDeploymentScriptStep beforePreDeploy = null;

        // Loop through all steps in the deployment plan
        while (nextStep != null)
        {
            // Increment the step pointer, saving both the current and next steps
            DeploymentStep currentStep = nextStep;
            nextStep = currentStep.Next;

            // Add additional step processing here
        }

        // if we found steps that required processing, set up a temporary table to track the work that you are doing
        if (beforePreDeploy != null)
        {
            // Add additional post-processing here
        }

        // Cleanup and drop the table 
        DeploymentScriptStep dropStep = new DeploymentScriptStep(DropCompletedBatchesTable);
        base.AddAfter(context.PlanHandle, context.PlanHandle.Tail, dropStep);

            ' Obtain the first step in the Plan from the provided context 
        Dim nextStep As DeploymentStep = context.PlanHandle.Head
        Dim batchId As Integer = 0
        Dim beforePreDeploy As BeginPreDeploymentScriptStep = Nothing

        ' Loop through all steps in the deployment plan 
        While nextStep IsNot Nothing
            ' Increment the step pointer, saving both the current and next steps 
            Dim currentStep As DeploymentStep = nextStep
            nextStep = currentStep.[Next]

            '  Add additional step processing here
        End While

        ' if we found steps that required processing, set up a temporary table to track the work that you are doing 
        If beforePreDeploy IsNot Nothing Then
            '  Add additional post-processing here
        End If

        ' Cleanup and drop the table 
        Dim dropStep As New DeploymentScriptStep(DropCompletedBatchesTable)
        MyBase.AddAfter(context.PlanHandle, context.PlanHandle.Tail, dropStep)

    在这段代码中，我们定义几个局部变量，并设置对部署计划中所有步骤进行处理的循环。 在循环完成后，我们必须执行一些后续处理，然后丢弃我们在部署过程中为跟踪计划执行进度而创建的临时表。 此处的关键类型为：DeploymentStep 和 DeploymentScriptStep。 关键方法为 AddAfter。

  3. 现在另外添加一些步骤处理，以替换“Add additional step processing here”这段注释：

                // Look for steps that mark the pre/post deployment scripts
            // These steps will always be in the deployment plan even if the
            // user's project does not have a pre/post deployment script
            if (currentStep is BeginPreDeploymentScriptStep)
            {
                // This step marks the begining of the predeployment script.
                // Save the step and move on.
                beforePreDeploy = (BeginPreDeploymentScriptStep)currentStep;
                continue;
            }
            if (currentStep is BeginPostDeploymentScriptStep)
            {
                // This is the step that marks the beginning of the post deployment script.  
                // We do not continue processing after this point.
                break;
            }
            if (currentStep is SqlPrintStep)
            {
                // We do not need to put if statements around these
                continue;
            }

            // if we have not yet found the beginning of the pre-deployment script steps, 
            // skip to the next step.
            if (beforePreDeploy == null)
            {
                // We only surround the "main" statement block with conditional
                // statements
                continue;
            }

            // Determine if this is a step that we need to surround with a conditional statement
            DeploymentScriptDomStep domStep = currentStep as DeploymentScriptDomStep ;
            if (domStep == null)
            {
                // This step is not a step that we know how to modify,
                // so skip to the next step.
                continue;
            }

            TSqlScript script = domStep.Script as TSqlScript;
            if (script == null)
            {
                // The script dom step does not have a script with batches - skip
                continue;
            }

            // Loop through all the batches in the script for this step.  All the statements
            // in the batch will be enclosed in an if statement that will check the
            // table to ensure that the batch has not already been executed
            IModelElement element;
            string stepDescription;
            GetStepInfo(context, domStep, out stepDescription, out element);
            int batchCount = script.Batches.Count;

            for (int batchIndex = 0; batchIndex < batchCount; batchIndex++)
            {
                // Add batch processing here
            }

                ' Look for steps that mark the pre/post deployment scripts 
            ' These steps will always be in the deployment plan even if the 
            ' user's project does not have a pre/post deployment script 
            If TypeOf currentStep Is BeginPreDeploymentScriptStep Then
                ' This step marks the begining of the predeployment script. 
                ' Save the step and move on. 
                beforePreDeploy = DirectCast(currentStep, BeginPreDeploymentScriptStep)
                Continue While
            End If
            If TypeOf currentStep Is BeginPostDeploymentScriptStep Then
                ' This is the step that marks the beginning of the post deployment script. 
                ' We do not continue processing after this point. 
                Exit While
            End If
            If TypeOf currentStep Is SqlPrintStep Then
                ' We do not need to put if statements around these 
                Continue While
            End If

            ' if we have not yet found the beginning of the pre-deployment script steps, 
            ' skip to the next step. 
            If beforePreDeploy Is Nothing Then
                ' We only surround the "main" statement block with conditional 
                ' statements 
                Continue While
            End If

            ' Determine if this is a step that we need to surround with a conditional statement 
            Dim domStep As DeploymentScriptDomStep = TryCast(currentStep, DeploymentScriptDomStep)
            If domStep Is Nothing Then
                ' This step is not a step that we know how to modify, 
                ' so skip to the next step. 
                Continue While
            End If

            Dim script As TSqlScript = TryCast(domStep.Script, TSqlScript)
            If script Is Nothing Then
                ' The script dom step does not have a script with batches - skip 
                Continue While
            End If

            ' Loop through all the batches in the script for this step. All the statements 
            ' in the batch will be enclosed in an if statement that will check the 
            ' table to ensure that the batch has not already been executed 
            Dim element As IModelElement = Nothing
            Dim stepDescription As String = ""
            GetStepInfo(context, domStep, stepDescription, element)
            Dim batchCount As Integer = script.Batches.Count

            For batchIndex As Integer = 0 To batchCount - 1
                ' Add batch processing here
            Next

    代码注释对处理进行了解释。 在较高层次上，这段代码查找您关注的步骤，跳过其他步骤并在您到达后期部署步骤的开头时停止。 如果步骤包含必须使用条件围绕的语句，则会执行其他处理。 关键类型、方法和属性包括：BeginPreDeploymentScriptStep、BeginPostDeploymentScriptStep、IModelElement、TSqlScript、Script、DeploymentScriptDomStep 和 SqlPrintStep。

  4. 现在，通过替换“Add batch processing here”这段注释来添加批处理代码：

                        // Create the if statement that will contain the batch's contents
                    IfStatement ifBatchNotExecutedStatement = CreateIfNotExecutedStatement(batchId);
                    BeginEndBlockStatement statementBlock = new BeginEndBlockStatement();
                    ifBatchNotExecutedStatement.ThenStatement = statementBlock;
                    statementBlock.StatementList = new StatementList();

                    TSqlBatch batch = script.Batches[batchIndex];
                    int statementCount = batch.Statements.Count;

                    // Loop through all statements in the batch, embedding those in an sp_execsql
                    // statement that must be handled this way (schemas, stored procedures, 
                    // views, functions, and triggers).
                    for (int statementIndex = 0; statementIndex < statementCount; statementIndex++)
                    {
                        // Add additional statement processing here
                    }

                    // Add an insert statement to track that all the statements in this
                    // batch were executed.  Turn on nocount to improve performance by
                    // avoiding row inserted messages from the server
                    string batchDescription = string.Format(CultureInfo.InvariantCulture,
                        "{0} batch {1}", stepDescription, batchIndex);

                    PredicateSetStatement noCountOff = new PredicateSetStatement();
                    noCountOff.IsOn = false;
                    noCountOff.Options = SetOptions.NoCount;

                    PredicateSetStatement noCountOn = new PredicateSetStatement();
                    noCountOn.IsOn = true;
                    noCountOn.Options = SetOptions.NoCount; 
                    InsertStatement batchCompleteInsert = CreateBatchCompleteInsert(batchId, batchDescription);
                    statementBlock.StatementList.Statements.Add(noCountOn);
                    statementBlock.StatementList.Statements.Add(batchCompleteInsert);
                    statementBlock.StatementList.Statements.Add(noCountOff);

                    // Remove all the statements from the batch (they are now in the if block) and add the if statement
                    // as the sole statement in the batch
                    batch.Statements.Clear();
                    batch.Statements.Add(ifBatchNotExecutedStatement);

                    // Next batch
                    batchId++;

                    ' Create the if statement that will contain the batch's contents 
                Dim ifBatchNotExecutedStatement As IfStatement = CreateIfNotExecutedStatement(batchId)
                Dim statementBlock As New BeginEndBlockStatement()
                ifBatchNotExecutedStatement.ThenStatement = statementBlock
                statementBlock.StatementList = New StatementList()

                Dim batch As TSqlBatch = script.Batches(batchIndex)
                Dim statementCount As Integer = batch.Statements.Count

                ' Loop through all statements in the batch, embedding those in an sp_execsql 
                ' statement that must be handled this way (schemas, stored procedures, 
                ' views, functions, and triggers). 
                For statementIndex As Integer = 0 To statementCount - 1
                    ' Add additional statement processing here
                Next

                ' Add an insert statement to track that all the statements in this 
                ' batch were executed. Turn on nocount to improve performance by 
                ' avoiding row inserted messages from the server 
                Dim batchDescription As String = String.Format(CultureInfo.InvariantCulture, "{0} batch {1}", stepDescription, batchIndex)

                Dim noCountOff As New PredicateSetStatement()
                noCountOff.IsOn = False
                noCountOff.Options = SetOptions.NoCount

                Dim noCountOn As New PredicateSetStatement()
                noCountOn.IsOn = True
                noCountOn.Options = SetOptions.NoCount
                Dim batchCompleteInsert As InsertStatement = CreateBatchCompleteInsert(batchId, batchDescription)
                statementBlock.StatementList.Statements.Add(noCountOn)
                statementBlock.StatementList.Statements.Add(batchCompleteInsert)
                statementBlock.StatementList.Statements.Add(noCountOff)

                ' Remove all the statements from the batch (they are now in the if block) and add the if statement 
                ' as the sole statement in the batch 
                batch.Statements.Clear()
                batch.Statements.Add(ifBatchNotExecutedStatement)

                ' Next batch 
                batchId += 1

    这段代码创建一个 IF 语句以及一个 BEGIN/END 块。 我们随后对批处理代码中的语句执行其他处理。 一旦该操作完成，我们便添加 INSERT 语句，以将信息添加到跟踪脚本执行进度的临时表。 最后，更新批处理代码，将其中原有的语句替换为其中包含这些语句的新 IF。

    关键类型、方法和属性包括：IfStatement、BeginEndBlockStatement、StatementList、TSqlBatch、PredicateSetStatement、SetOptions 和 InsertStatement。

  5. 现在，添加语句处理循环的主体。 替换“Add additional statement processing here”这段注释：

                            TSqlStatement smnt = batch.Statements[statementIndex];

                        if (IsStatementEscaped(element))
                        {
                            // "escape" this statement by embedding it in a sp_executesql statement
                            string statementScript = null;
                            domStep.ScriptGenerator.GenerateScript(smnt, out statementScript);
                            ExecuteStatement spExecuteSql = CreateExecuteSql(statementScript);
                            smnt = spExecuteSql;
                        }

                        statementBlock.StatementList.Statements.Add(smnt);

                        Dim smnt As TSqlStatement = batch.Statements(statementIndex)

                    If IsStatementEscaped(element) Then
                        ' "escape" this statement by embedding it in a sp_executesql statement 
                        Dim statementScript As String = Nothing
                        domStep.ScriptGenerator.GenerateScript(smnt, statementScript)
                        Dim spExecuteSql As ExecuteStatement = CreateExecuteSql(statementScript)
                        smnt = spExecuteSql
                    End If

                    statementBlock.StatementList.Statements.Add(smnt)

    对于批处理代码中的每条语句，如果该语句属于必须使用 sp_executesql 语句进行围绕的类型，则对该语句进行相应修改。 代码随后将语句添加到您创建的 BEGIN/END 块的语句列表。 关键类型、方法和属性包括 TSqlStatement 和 ExecuteStatement。

  6. 最后，使用后期处理部分替换“Add additional post-processing here”这段注释。

                    // Declare a SqlCmd variables.
                //
                // CompletedBatches variable - defines the name of the table in tempdb that will track
                // all the completed batches.  The temporary table's name has the target database name and
                // a guid embedded in it so that:
                // * Multiple deployment scripts targeting different DBs on the same server
                // * Failed deployments with old tables do not conflict with more recent deployments
                //
                // TotalBatchCount variable - the total number of batches surrounded by if statements.  Using this
                // variable pre/post deployment scripts can also use the CompletedBatches table to make their
                // script rerunnable if there is an error during execution
                StringBuilder sqlcmdVars = new StringBuilder();
                sqlcmdVars.AppendFormat(CultureInfo.InvariantCulture, CompletedBatchesSqlCmd,
                    context.Options.TargetDatabaseName, Guid.NewGuid().ToString("D"));
                sqlcmdVars.AppendLine();
                sqlcmdVars.AppendFormat(CultureInfo.InvariantCulture, TotalBatchCountSqlCmd, batchId);

                DeploymentScriptStep completedBatchesSetVarStep = new DeploymentScriptStep(sqlcmdVars.ToString());
                base.AddBefore(context.PlanHandle, beforePreDeploy, completedBatchesSetVarStep);

                // Create the temporary table we will use to track the work that we are doing
                DeploymentScriptStep createStatusTableStep = new DeploymentScriptStep(CreateCompletedBatchesTable);
                base.AddBefore(context.PlanHandle, beforePreDeploy, createStatusTableStep);

                ' Declare a SqlCmd variables. 
            ' 
            ' CompletedBatches variable - defines the name of the table in tempdb that will track 
            ' all the completed batches. The temporary table's name has the target database name and 
            ' a guid embedded in it so that: 
            ' * Multiple deployment scripts targeting different DBs on the same server 
            ' * Failed deployments with old tables do not conflict with more recent deployments 
            ' 
            ' TotalBatchCount variable - the total number of batches surrounded by if statements. Using this 
            ' variable pre/post deployment scripts can also use the CompletedBatches table to make their 
            ' script rerunnable if there is an error during execution 
            Dim sqlcmdVars As New StringBuilder()
            sqlcmdVars.AppendFormat(CultureInfo.InvariantCulture, CompletedBatchesSqlCmd, context.Options.TargetDatabaseName, Guid.NewGuid().ToString("D"))
            sqlcmdVars.AppendLine()
            sqlcmdVars.AppendFormat(CultureInfo.InvariantCulture, TotalBatchCountSqlCmd, batchId)

            Dim completedBatchesSetVarStep As New DeploymentScriptStep(sqlcmdVars.ToString())
            MyBase.AddBefore(context.PlanHandle, beforePreDeploy, completedBatchesSetVarStep)

            ' Create the temporary table we will use to track the work that we are doing 
            Dim createStatusTableStep As New DeploymentScriptStep(CreateCompletedBatchesTable)
            MyBase.AddBefore(context.PlanHandle, beforePreDeploy, createStatusTableStep)

    如果我们的处理发现一个或多个使用条件语句围绕的步骤，我们必须将语句添加到部署脚本以定义 SQLCMD 变量。 第一个变量 CompletedBatches 包含临时表的唯一名称，部署脚本使用该临时表跟踪在执行脚本时成功完成的批处理。 第二个变量 TotalBatchCount 包含部署脚本中的批处理总数。

    其他相关类型、属性和方法包括：

    StringBuilder、DeploymentScriptStep 和 AddBefore。

    接下来，定义此方法调用的帮助器方法。

添加 CreateExecuteSql 方法

  • 添加下面的代码，以定义 CreateExecuteSQL 方法，从而使用 EXEC sp_executesql 语句围绕提供的语句：

            /// <summary>
        /// The CreateExecuteSql method "wraps" the provided statement script in an "sp_executesql" statement
        /// Examples of statements that must be so wrapped include: stored procedures, views, and functions
        /// </summary>
        /// <param name="string"></param>
        /// <returns></returns>
        private static ExecuteStatement CreateExecuteSql(string statementScript)
        {
            // define a new Exec statement
            ExecuteStatement executeSp = new ExecuteStatement();
            ExecutableProcedureReference spExecute = new ExecutableProcedureReference();
            executeSp.ExecutableEntity = spExecute;

            // define the name of the procedure that you want to execute, in this case sp_executesql
            SchemaObjectName procName = new SchemaObjectName();
            procName.Identifiers.Add(CreateIdentifier("sp_executesql", QuoteType.NotQuoted));
            ProcedureReference procRef = new ProcedureReference();
            procRef.Name = procName;
            spExecute.ProcedureReference = procRef;

            // add the script parameter, constructed from the provided statement script
            ExecuteParameter scriptParam = new ExecuteParameter();
            spExecute.Parameters.Add(scriptParam);
            scriptParam.ParameterValue = CreateLiteral(statementScript, LiteralType.UnicodeStringLiteral);
            scriptParam.Variable = CreateLiteral("@stmt", LiteralType.Variable);
            return executeSp;
        }

        ''' <summary> 
    ''' The CreateExecuteSql method "wraps" the provided statement script in an "sp_executesql" statement 
    ''' Examples of statements that must be so wrapped include: stored procedures, views, and functions 
    ''' </summary> 
    ''' <param name="statementScript"></param> 
    ''' <returns></returns> 
    Private Shared Function CreateExecuteSql(ByVal statementScript As String) As ExecuteStatement
        ' define a new Exec statement 
        Dim executeSp As New ExecuteStatement()
        Dim spExecute As New ExecutableProcedureReference()
        executeSp.ExecutableEntity = spExecute

        ' define the name of the procedure that you want to execute, in this case sp_executesql 
        Dim procName As New SchemaObjectName()
        procName.Identifiers.Add(CreateIdentifier("sp_executesql", QuoteType.NotQuoted))
        Dim procRef As New ProcedureReference()
        procRef.Name = procName
        spExecute.ProcedureReference = procRef

        ' add the script parameter, constructed from the provided statement script 
        Dim scriptParam As New ExecuteParameter()
        spExecute.Parameters.Add(scriptParam)
        scriptParam.ParameterValue = CreateLiteral(statementScript, LiteralType.UnicodeStringLiteral)
        scriptParam.Variable = CreateLiteral("@stmt", LiteralType.Variable)
        Return executeSp
    End Function

    关键类型、方法和属性包括：ExecuteStatement、ExecutableProcedureReference、SchemaObjectName、ProcedureReference 和 ExecuteParameter。

添加 CreateLiteral 方法

  • 添加以下代码以定义 CreateLiteral 方法。 此方法从提供的字符串创建指定类型的 Literal 对象：

            /// <summary>
        /// The CreateLiteral method creates a Literal object of the specified type from the provided string
        /// </summary>
        /// <param name="value"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        private static Literal CreateLiteral(string value, LiteralType type)
        {
            Literal l = new Literal();
            l.Value = value;
            l.LiteralType = type;
            return l;
        }

        ''' <summary> 
    ''' The CreateLiteral method creates a Literal object of the specified type from the provided string 
    ''' </summary> 
    ''' <param name="value"></param> 
    ''' <param name="type"></param> 
    ''' <returns></returns> 
    Private Shared Function CreateLiteral(ByVal value As String, ByVal type As LiteralType) As Literal
        Dim l As New Literal()
        l.Value = value
        l.LiteralType = type
        Return l
    End Function

    关键类型、方法和属性包括：Literal 和 LiteralType。

添加 CreateIdentifier 方法

  • 添加以下代码以定义 CreateIdentifier 方法。 此方法创建 Identifier 对象，该对象使用引用自提供的字符串的指定类型：

            /// <summary>
        /// The CreateIdentifier method returns a Identifier with the specified value and quoting type
        /// </summary>
        /// <param name="value"></param>
        /// <param name="quoteType"></param>
        /// <returns></returns>
        private static Identifier CreateIdentifier(string value, QuoteType quoteType)
        {
            Identifier id = new Identifier();
            id.Value = value;
            id.QuoteType = quoteType;
            return id;
        }

        ''' <summary> 
    ''' The CreateIdentifier method returns a Identifier with the specified value and quoting type 
    ''' </summary> 
    ''' <param name="value"></param> 
    ''' <param name="quoteType"></param> 
    ''' <returns></returns> 
    Private Shared Function CreateIdentifier(ByVal value As String, ByVal quoteType As QuoteType) As Identifier
        Dim id As New Identifier()
        id.Value = value
        id.QuoteType = quoteType
        Return id
    End Function

    关键类型、方法和属性包括：Identifier 和 QuoteType。

添加 CreateCompletedBatchesName 方法

  • 添加以下代码以定义 CreateCompletedBatchesName 方法。 此方法创建要针对某个批处理插入到临时表中的名称。

            /// <summary>
        /// The CreateCompletedBatchesName method creates the name that will be inserted
        /// into the temporary table for a batch.
        /// </summary>
        /// <returns></returns>
        private static SchemaObjectName CreateCompletedBatchesName()
        {
            SchemaObjectName name = new SchemaObjectName();
            name.Identifiers.Add(CreateIdentifier("tempdb", QuoteType.SquareBracket));
            name.Identifiers.Add(CreateIdentifier("dbo", QuoteType.SquareBracket));
            name.Identifiers.Add(CreateIdentifier(CompletedBatchesVariable, QuoteType.SquareBracket));
            return name;
        }

        ''' <summary> 
    ''' The CreateCompletedBatchesName method creates the name that will be inserted 
    ''' into the temporary table for a batch. 
    ''' </summary> 
    ''' <returns></returns> 
    Private Shared Function CreateCompletedBatchesName() As SchemaObjectName
        Dim name As New SchemaObjectName()
        name.Identifiers.Add(CreateIdentifier("tempdb", QuoteType.SquareBracket))
        name.Identifiers.Add(CreateIdentifier("dbo", QuoteType.SquareBracket))
        name.Identifiers.Add(CreateIdentifier(CompletedBatchesVariable, QuoteType.SquareBracket))
        Return name
    End Function

    关键类型、方法和属性包括：SchemaObjectName。

添加 IsStatementEscaped 方法

  • 添加以下代码以定义 IsStatementEscaped 方法。 此方法确定模型元素的类型是否求将语句围绕在 EXEC sp_executesql 语句中，才能在 IF 语句中包含该语句。

            /// <summary>
        /// Helper method that determins whether the specified statement needs to
        /// be escaped
        /// </summary>
        /// <param name="smnt"></param>
        /// <returns></returns>
        private static bool IsStatementEscaped(IModelElement element)
        {
            return element is ISql90Schema
                || element is ISqlProcedure
                || element is ISqlView
                || element is ISqlFunction
                || element is ISqlTrigger;
        }

        ''' <summary> 
    ''' Helper method that determins whether the specified statement needs to 
    ''' be escaped 
    ''' </summary> 
    ''' <param name="element"></param> 
    ''' <returns></returns> 
    Private Shared Function IsStatementEscaped(ByVal element As IModelElement) As Boolean
        Return TypeOf element Is ISql90Schema OrElse TypeOf element Is ISqlProcedure OrElse TypeOf element Is ISqlView OrElse TypeOf element Is ISqlFunction OrElse TypeOf element Is ISqlTrigger
    End Function

    关键类型、方法和属性包括：IModelElement、ISql90Schema、ISqlProcedure、ISqlView、ISqlFunction 和 ISqlTrigger。

添加 CreateBatchCompleteInsert 方法

  • 添加以下代码以定义 CreateBatchCompleteInsert 方法。 此方法创建要添加到部署脚本的 INSERT 语句，用于跟踪脚本执行的进度：

            /// <summary>
        /// Helper method that creates an INSERT statement to track a batch being completed
        /// </summary>
        /// <param name="batchId"></param>
        /// <param name="batchDescription"></param>
        /// <returns></returns>
        private static InsertStatement CreateBatchCompleteInsert(int batchId, string batchDescription)
        {
            InsertStatement insert = new InsertStatement();
            SchemaObjectDataModificationTarget batchesCompleted = new SchemaObjectDataModificationTarget();
            insert.Target = batchesCompleted;
            batchesCompleted.SchemaObject = CreateCompletedBatchesName();

            // Build the columns inserted into
            Column batchIdColumn = new Column();
            batchIdColumn.Identifiers.Add(CreateIdentifier(BatchIdColumnName, QuoteType.NotQuoted));

            Column descriptionColumn = new Column();
            descriptionColumn.Identifiers.Add(CreateIdentifier(DescriptionColumnName, QuoteType.NotQuoted));

            insert.Columns.Add(batchIdColumn);
            insert.Columns.Add(descriptionColumn);

            // Build the values inserted
            ValuesInsertSource valueSource = new ValuesInsertSource();
            insert.InsertSource = valueSource;

            RowValue values = new RowValue();
            values.ColumnValues.Add(CreateLiteral(batchId.ToString(), LiteralType.Integer));
            values.ColumnValues.Add(CreateLiteral(batchDescription, LiteralType.UnicodeStringLiteral));
            valueSource.RowValues.Add(values);

            return insert;
        }

        ''' <summary> 
    ''' Helper method that creates an INSERT statement to track a batch being completed 
    ''' </summary> 
    ''' <param name="batchId"></param> 
    ''' <param name="batchDescription"></param> 
    ''' <returns></returns> 
    Private Shared Function CreateBatchCompleteInsert(ByVal batchId As Integer, ByVal batchDescription As String) As InsertStatement
        Dim insert As New InsertStatement()
        Dim batchesCompleted As New SchemaObjectDataModificationTarget()
        insert.Target = batchesCompleted
        batchesCompleted.SchemaObject = CreateCompletedBatchesName()

        ' Build the columns inserted into 
        Dim batchIdColumn As New Column()
        batchIdColumn.Identifiers.Add(CreateIdentifier(BatchIdColumnName, QuoteType.NotQuoted))

        Dim descriptionColumn As New Column()
        descriptionColumn.Identifiers.Add(CreateIdentifier(DescriptionColumnName, QuoteType.NotQuoted))

        insert.Columns.Add(batchIdColumn)
        insert.Columns.Add(descriptionColumn)

        ' Build the values inserted 
        Dim valueSource As New ValuesInsertSource()
        insert.InsertSource = valueSource

        Dim values As New RowValue()
        values.ColumnValues.Add(CreateLiteral(batchId.ToString(), LiteralType.[Integer]))
        values.ColumnValues.Add(CreateLiteral(batchDescription, LiteralType.UnicodeStringLiteral))
        valueSource.RowValues.Add(values)

        Return insert
    End Function

    关键类型、方法和属性包括：InsertStatement、SchemaObjectDataModificationTarget、Column、ValuesInsertSource 和 RowValue。

添加 CreateIfNotExecutedStatement 方法

  • 添加以下代码以定义 CreateIfNotExecutedStatement 方法。 此方法生成 IF 语句，该语句检查临时批处理执行表是否指示已执行此批处理：

            /// <summary>
        /// This is a helper method that generates an if statement that checks the batches executed
        /// table to see if the current batch has been executed.  The if statement will look like this
        /// 
        /// if not exists(select 1 from [tempdb].[dbo].[$(CompletedBatches)] 
        ///                where BatchId = batchId)
        /// begin
        /// end
        /// </summary>
        /// <param name="batchId"></param>
        /// <returns></returns>
        private static IfStatement CreateIfNotExecutedStatement(int batchId)
        {
            // Create the exists/select statement
            ExistsPredicate existsExp = new ExistsPredicate();
            Subquery subQuery = new Subquery();
            existsExp.Subquery = subQuery;

            QuerySpecification select = new QuerySpecification();
            subQuery.QueryExpression = select;
            select.SelectElements.Add(CreateLiteral("1", LiteralType.Integer));
            SchemaObjectTableSource completedBatchesTable = new SchemaObjectTableSource();
            select.FromClauses.Add(completedBatchesTable);
            completedBatchesTable.SchemaObject = CreateCompletedBatchesName();

            WhereClause where = new WhereClause();
            select.WhereClause = where;

            Column batchIdColumn = new Column();
            batchIdColumn.Identifiers.Add(CreateIdentifier(BatchIdColumnName, QuoteType.SquareBracket));
            Literal batchIdValue = CreateLiteral(batchId.ToString(), LiteralType.Integer);

            BinaryExpression stepsEqual = new BinaryExpression();
            where.SearchCondition = stepsEqual;
            stepsEqual.BinaryExpressionType = BinaryExpressionType.Equals;
            stepsEqual.FirstExpression = batchIdColumn;
            stepsEqual.SecondExpression = batchIdValue;

            // Put together the rest of the statement
            IfStatement ifNotExists = new IfStatement();
            UnaryExpression notExp = new UnaryExpression();
            ifNotExists.Predicate = notExp;
            notExp.UnaryExpressionType = UnaryExpressionType.Not;
            notExp.Expression = existsExp;

            return ifNotExists;
        }

        ''' <summary> 
    ''' This is a helper method that generates an if statement that checks the batches executed 
    ''' table to see if the current batch has been executed. The if statement will look like this 
    ''' 
    ''' if not exists(select 1 from [tempdb].[dbo].[$(CompletedBatches)] 
    ''' where BatchId = batchId) 
    ''' begin 
    ''' end 
    ''' </summary> 
    ''' <param name="batchId"></param> 
    ''' <returns></returns> 
    Private Shared Function CreateIfNotExecutedStatement(ByVal batchId As Integer) As IfStatement
        ' Create the exists/select statement 
        Dim existsExp As New ExistsPredicate()
        Dim subQuery As New Subquery()
        existsExp.Subquery = subQuery

        Dim [select] As New QuerySpecification()
        subQuery.QueryExpression = [select]
        [select].SelectElements.Add(CreateLiteral("1", LiteralType.[Integer]))
        Dim completedBatchesTable As New SchemaObjectTableSource()
        [select].FromClauses.Add(completedBatchesTable)
        completedBatchesTable.SchemaObject = CreateCompletedBatchesName()

        Dim where As New WhereClause()
        [select].WhereClause = where

        Dim batchIdColumn As New Column()
        batchIdColumn.Identifiers.Add(CreateIdentifier(BatchIdColumnName, QuoteType.SquareBracket))
        Dim batchIdValue As Literal = CreateLiteral(batchId.ToString(), LiteralType.[Integer])

        Dim stepsEqual As New BinaryExpression()
        where.SearchCondition = stepsEqual
        stepsEqual.BinaryExpressionType = BinaryExpressionType.Equals
        stepsEqual.FirstExpression = batchIdColumn
        stepsEqual.SecondExpression = batchIdValue

        ' Put together the rest of the statement 
        Dim ifNotExists As New IfStatement()
        Dim notExp As New UnaryExpression()
        ifNotExists.Predicate = notExp
        notExp.UnaryExpressionType = UnaryExpressionType.[Not]
        notExp.Expression = existsExp

        Return ifNotExists
    End Function

    关键类型、方法和属性包括：IfStatement、ExistsPredicate、Subquery、SchemaObjectTableSource、WhereClause、Column、Literal、BinaryExpression 和 UnaryExpression

添加 GetStepInfo 方法

  1. 添加以下代码以定义 GetStepInfo 方法。 此方法：

            /// <summary>
        /// Helper method that generates a useful description of the step.
        /// </summary>
        /// <param name="context"></param>
        /// <param name="domStep"></param>
        /// <param name="stepDescription"></param>
        /// <param name="element"></param>
        private static void GetStepInfo(
            DeploymentPlanContributorContext context, 
            DeploymentScriptDomStep domStep,
            out string stepDescription,
            out IModelElement element)
        {
            element = null;
            CreateElementStep createStep = null;
            AlterElementStep alterStep = null;
            DropElementStep dropStep = null;

            // figure out what type of step we've got, and retrieve
            // either the source or target element.
            if ((createStep = domStep as CreateElementStep) != null)
            {
                element = createStep.SourceElement;
            }
            else if ((alterStep = domStep as AlterElementStep) != null)
            {
                element = alterStep.SourceElement;
            }
            else if ((dropStep = domStep as DropElementStep) != null)
            {
                element = dropStep.TargetElement;
            }

            // construct the step description by concatenating the type and the fully qualified
            // name of the associated element.
            string stepTypeName = domStep.GetType().Name;
            if (element != null)
            {
                string elementName = context.Source.DatabaseSchemaProvider.UserInteractionServices.GetElementName(
                    element, Microsoft.Data.Schema.ElementNameStyle.FullyQualifiedName);

                stepDescription = string.Format(CultureInfo.InvariantCulture, "{0} {1}",
                    stepTypeName, elementName);
            }
            else
            {
                // if the step has no associated element, just use the step type as the description
                stepDescription = stepTypeName;
            }
        }

        ''' <summary> 
    ''' Helper method that generates a useful description of the step. 
    ''' </summary> 
    ''' <param name="context"></param> 
    ''' <param name="domStep"></param> 
    ''' <param name="stepDescription"></param> 
    ''' <param name="element"></param> 
    Private Shared Sub GetStepInfo(ByVal context As DeploymentPlanContributorContext, ByVal domStep As DeploymentScriptDomStep, ByRef stepDescription As String, ByRef element As IModelElement)
        element = Nothing
        Dim createStep As CreateElementStep = Nothing
        Dim alterStep As AlterElementStep = Nothing
        Dim dropStep As DropElementStep = Nothing

        ' figure out what type of step we've got, and retrieve 
        ' either the source or target element. 
        If (InlineAssignHelper(createStep, TryCast(domStep, CreateElementStep))) IsNot Nothing Then
            element = createStep.SourceElement
        ElseIf (InlineAssignHelper(alterStep, TryCast(domStep, AlterElementStep))) IsNot Nothing Then
            element = alterStep.SourceElement
        ElseIf (InlineAssignHelper(dropStep, TryCast(domStep, DropElementStep))) IsNot Nothing Then
            element = dropStep.TargetElement
        End If

        ' construct the step description by concatenating the type and the fully qualified 
        ' name of the associated element. 
        Dim stepTypeName As String = domStep.[GetType]().Name
        If element IsNot Nothing Then
            Dim elementName As String = context.Source.DatabaseSchemaProvider.UserInteractionServices.GetElementName(element, Microsoft.Data.Schema.ElementNameStyle.FullyQualifiedName)

            stepDescription = String.Format(CultureInfo.InvariantCulture, "{0} {1}", stepTypeName, elementName)
        Else
            ' if the step has no associated element, just use the step type as the description 
            stepDescription = stepTypeName
        End If
    End Sub
    Private Shared Function InlineAssignHelper(Of T)(ByRef target As T, ByVal value As T) As T
        target = value
        Return value
    End Function

    相关类型和方法包括：DeploymentPlanContributorContext、DeploymentScriptDomStep、IModelElement、CreateElementStep、AlterElementStep 和 DropElementStep。

  2. 将更改保存到 Class1.cs 中。

    接下来生成类库。

为程序集签名并生成程序集

  1. 在**“项目”菜单上，单击“MyOtherDeploymentContributor 属性”**。

  2. 单击**“签名”**选项卡。

  3. 单击**“为程序集签名”**。

  4. 在**“选择强名称密钥文件”中，单击“<新建>”**。

  5. 在**“创建强名称密钥”对话框中的“密钥文件名称”**中，键入 MyRefKey。

  6. （可选）可以为强名称密钥文件指定密码。

  7. 单击**“确定”**。

  8. 在**“文件”菜单上，单击“全部保存”**。

  9. 在**“生成”菜单上，单击“生成解决方案”**。

    接下来，必须安装并注册程序集，以便在部署数据库项目时将加载该程序集。

安装部署参与者

若要安装部署参与者，必须执行以下任务：

  • 将程序集和关联的 .pdb 文件复制到 Extensions 文件夹

  • 创建 Extensions.xml 文件以注册部署参与者，从而使其可在您部署数据库项目时进行加载

安装 MyOtherDeploymentContributor 程序集

  1. 在 %Program Files%\Microsoft Visual Studio 10.0\VSTSDB\Extensions 文件夹中创建一个名为 MyExtensions 的文件夹。

  2. 将经过签名的程序集 (MyOtherDeploymentContributor.dll) 复制到 %Program Files%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\MyExtensions 文件夹。

    提示

    建议您不要将 XML 文件直接复制到 %Program Files%\Microsoft Visual Studio 10.0\VSTSDB\Extensions 文件夹中。 如果您改用一个子文件夹，则可以防止意外地更改随 Visual Studio 提供的其他文件。

    接下来，必须注册程序集（即，某种类型的功能扩展），以便在 Visual Studio 中显示该程序集。

注册 MyOtherDeploymentContributor 程序集

  1. 在**“视图”菜单上，单击“其他窗口”，然后单击“命令窗口”打开“命令”**窗口。

  2. 在**“命令”**窗口中，键入以下代码。 将 FilePath 替换为已编译的 .dll 文件的路径和文件名。 在路径和文件名的两侧加双引号。

    提示

    默认情况下，已编译的 .dll 文件的路径是“您的解决方案路径\bin\Debug”或“您的解决方案路径\bin\Release”。

    ? System.Reflection.Assembly.LoadFrom(@"FilePath").FullName

    ? System.Reflection.Assembly.LoadFrom("FilePath").FullName

  3. 按 Enter。

  4. 将所得到的行复制到剪贴板上。 该行应该与下面的内容类似：

    "GeneratorAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=nnnnnnnnnnnnnnnn"

  5. 打开纯文本编辑器，如“记事本”。

    重要说明重要事项

    在 Windows Vista 和 Microsoft Windows Server 2008 中，以管理员身份打开编辑器，以便您能够将文件保存到 Program Files 文件夹中。

  6. 提供以下信息，指定自己的程序集名称、公钥标记和扩展类型：

    <?xml version="1.0" encoding="utf-8" ?> 
<extensions assembly="" version="1" xmlns="urn:Microsoft.Data.Schema.Extensions" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="urn:Microsoft.Data.Schema.Extensions Microsoft.Data.Schema.Extensions.xsd">
  <extension type="MyOtherDeploymentContributor.SqlRestartableScriptContributor" 
assembly="MyOtherDeploymentContributor, Version=1.0.0.0, Culture=neutral, PublicKeyToken=<enter key here>" enabled="true" />
</extensions>

    使用此 XML 文件可注册从 DeploymentPlanExecutor 继承的类。

  7. 在 %Program Files%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\MyExtensions 文件夹中将文件保存为 MyOtherDeploymentContributor.extensions.xml。

  8. 关闭 Visual Studio。

    接下来，您将部署数据库项目以测试参与者。

测试部署参与者

若要测试部署参与者，必须执行以下任务：

  • 通过使用 MSBuild 并提供适当的参数以部署数据库项目

因为此部署参与者始终启用，所以不必为添加任何属性而修改数据库项目。

部署数据库项目

部署数据库项目并生成部署报告

  1. 打开一个 Visual Studio 命令提示符。 在**“开始”菜单上，依次单击“所有程序”、“Microsoft Visual Studio 2010”、“Visual Studio 工具”和“Visual Studio 命令提示(2010)”**。

  2. 在命令提示符下，定位到您的数据库项目所在的文件夹。

  3. 在命令提示符下，键入以下命令行：

    MSBuild /t:Deploy MyDatabaseProject.dbproj

    将 MyDatabaseProject 替换为要部署的数据库项目的名称。

  4. 检查得到的部署脚本。 在紧邻标记为“Pre-Deployment Script Template”的部分之前，您应看到类似于以下 Transact-SQL 的一些内容：

    :setvar CompletedBatches __completedBatches_CompareProjectDB_cd1e348a-8f92-44e0-9a96-d25d65900fca
:setvar TotalBatchCount 17
GO

if OBJECT_ID(N'tempdb.dbo.$(CompletedBatches)', N'U') is null
begin
use tempdb
create table [dbo].[$(CompletedBatches)]
(
BatchId int primary key,
Description nvarchar(300)
)
use [$(DatabaseName)]
end

    在部署脚本后面每个批处理的周围，您都会看到围绕原始语句的 IF 语句。 例如，对于 CREATE SCHEMA 语句可能出现以下内容：

    IF NOT EXISTS (SELECT 1
               FROM   [tempdb].[dbo].[$(CompletedBatches)]
               WHERE  [BatchId] = 0)
    BEGIN
        EXECUTE sp_executesql @stmt = N'CREATE SCHEMA [Sales]
    AUTHORIZATION [dbo]';
        SET NOCOUNT ON;
        INSERT  [tempdb].[dbo].[$(CompletedBatches)] (BatchId, Description)
        VALUES                                      (0, N'CreateElementStep Sales batch 0');
        SET NOCOUNT OFF;
    END

    请注意，CREATE SCHEMA 是在 IF 语句中必须包含在 EXECUTE sp_executesql 语句中的语句之一。 CREATE TABLE 这类语句不需要 EXECUTE sp_executesql 语句，类似于下面的示例：

    IF NOT EXISTS (SELECT 1
               FROM   [tempdb].[dbo].[$(CompletedBatches)]
               WHERE  [BatchId] = 1)
    BEGIN
        CREATE TABLE [Sales].[Customer] (
            [CustomerID]   INT           IDENTITY (1, 1) NOT NULL,
            [CustomerName] NVARCHAR (40) NOT NULL,
            [YTDOrders]    INT           NOT NULL,
            [YTDSales]     INT           NOT NULL
        );
        SET NOCOUNT ON;
        INSERT  [tempdb].[dbo].[$(CompletedBatches)] (BatchId, Description)
        VALUES                                      (1, N'CreateElementStep Sales.Customer batch 0');
        SET NOCOUNT OFF;
    END

    提示

    如果您部署的数据库项目与目标数据库相同，则生成的报告没有太大意义。 若要获得更有意义的结果，请将更改部署到数据库或部署新数据库。

    可以使用 DeploymentPlanModifier 来添加、移除或修改任何部署计划中的批处理或语句。

后续步骤

可以尝试在执行部署计划之前，对其进行其他类型的修改。 可能需要进行的某些其他类型的修改包括：向所有关联有版本号的数据库对象添加扩展属性、对部署脚本添加或移除其他诊断输出语句或注释，等等。

请参见

概念

扩展 Visual Studio 的数据库功能

其他资源

使用生成参与者和部署参与者自定义数据库生成和部署

演练：扩展数据库项目生成以生成模型统计信息

演练：扩展数据库项目部署以分析部署计划