Compartilhar via

Passo a passo: estender a implantação do projeto de banco de dados para analisar o plano de implantação

Você pode criar colaboradores de implantação para executar ações personalizadas ao implantar um projeto SQL. Você pode criar um DeploymentPlanModifier ou um DeploymentPlanExecutor. Use um DeploymentPlanModifier para alterar o plano antes de ser executado e um DeploymentPlanExecutor para executar operações enquanto o plano está sendo executado. Neste passo a passo, você cria um DeploymentPlanExecutor chamado DeploymentUpdateReportContributor que cria um relatório sobre as ações executadas ao implantar um projeto de banco de dados. Como esse colaborador de build aceita um parâmetro para controlar se o relatório é gerado, você deve executar outra etapa necessária.

Neste passo a passo, você realiza as seguintes tarefas principais:

Pré-requisitos

Você precisará dos seguintes componentes para concluir este passo a passo:

  • Você deve ter instalado uma versão do Visual Studio que inclua o SSDT (SQL Server Data Tools) e dê suporte ao desenvolvimento em C# ou VB.
  • Você deve ter um projeto SQL que contenha objetos SQL.
  • Uma instância do SQL Server na qual você pode implantar um projeto de banco de dados.

Observação

Este passo a passo destina-se a usuários que já estão familiarizados com os recursos sql do SSDT. Espera-se também que você esteja familiarizado com conceitos básicos do Visual Studio, como criar uma biblioteca de classes e como usar o editor de código para adicionar código a uma classe.

Criar um colaborador de implantação

Para criar um colaborador de implantação, você deve executar as seguintes tarefas:

  • Crie um projeto de biblioteca de classes e adicione referências necessárias.

  • Defina uma classe chamada DeploymentUpdateReportContributor que herda de DeploymentPlanExecutor.

  • Sobrescreva o método OnExecute.

  • Adicione uma classe auxiliar privada.

  • Monte o assembly resultante.

Criar um projeto de biblioteca de classes

  1. Crie um projeto de biblioteca de classes do Visual Basic ou C# chamado MyDeploymentContributor.

  2. Renomeie o arquivo "Class1.cs" como "DeploymentUpdateReportContributor.cs".

  3. No Gerenciador de Soluções, clique com o botão direito do mouse no nó do projeto e selecione Adicionar Referência.

  4. Selecione System.ComponentModel.Composition na guia Estruturas.

  5. Adicionar referências de SQL necessárias: clique com o botão direito do mouse no nó do projeto e selecione Adicionar Referência. Selecione Procurar e navegue até a pasta C:\Arquivos de Programas (x86)\Microsoft SQL Server\110\DAC\Bin . Escolha Microsoft.SqlServer.Dac.dll, Microsoft.SqlServer.Dac.Extensions.dll e Microsoft.Data.Tools.Schema.Sql.dll, selecione Adicionar e depois selecione OK.

    Em seguida, comece a adicionar código à classe.

Definir a classe DeploymentUpdateReportContributor

  1. No editor de código, atualize o arquivo DeploymentUpdateReportContributor.cs para corresponder ao seguinte usando instruções:

    using System;
using System.IO;
using System.Text;
using System.Xml;
using Microsoft.SqlServer.Dac.Deployment;
using Microsoft.SqlServer.Dac.Extensibility;
using Microsoft.SqlServer.Dac.Model;

  2. Atualize a definição de classe para corresponder ao seguinte código:

    /// <summary>
    /// An executor that generates a report detailing the steps in the deployment plan. Only runs if a
    /// "GenerateUpdateReport=true" contributor argument is set in the project file, in a targets file or
    /// passed as an additional argument to the DacServices API. To set in a project file, add:
    ///
    /// <PropertyGroup>
    ///     <ContributorArguments Condition="'$(Configuration)' == 'Debug'">
    /// $(ContributorArguments);DeploymentUpdateReportContributor.GenerateUpdateReport=true;
    ///     </ContributorArguments>
    /// <PropertyGroup>
    ///
    /// </summary>
    [ExportDeploymentPlanExecutor("MyDeploymentContributor.DeploymentUpdateReportContributor", "1.0.0.0")]
    public class DeploymentUpdateReportContributor : DeploymentPlanExecutor
    {
    }

    Agora você definiu o colaborador de implantação que herda do DeploymentPlanExecutor. Durante os processos de build e implantação, os contribuidores personalizados são carregados de um diretório de extensão padrão. Os colaboradores do executor do plano de implantação são identificados por um atributo ExportDeploymentPlanExecutor .

    Esse atributo é necessário para que os colaboradores possam ser descobertos. Ele deve ser semelhante ao seguinte código:

    [ExportDeploymentPlanExecutor("MyDeploymentContributor.DeploymentUpdateReportContributor", "1.0.0.0")]

    Nesse caso, o primeiro parâmetro para o atributo deve ser um identificador exclusivo - isso é usado para identificar seu colaborador em arquivos de projeto. Uma prática recomendada é combinar o namespace da biblioteca - neste passo a passo, MyDeploymentContributor - com o nome da classe - neste passo a passo, DeploymentUpdateReportContributor - para produzir o identificador.

  3. Em seguida, adicione o seguinte membro que você usa para permitir que esse provedor aceite um parâmetro de linha de comando:

    public const string GenerateUpdateReport = "DeploymentUpdateReportContributor.GenerateUpdateReport";

    Esse membro permite que o usuário especifique se o relatório deve ser gerado usando a opção GenerateUpdateReport.

    Em seguida, você substitui o método OnExecute para adicionar o código que deseja executar quando um projeto de banco de dados é implantado.

Sobrescrever OnExecute

  • Adicione o seguinte método à classe DeploymentUpdateReportContributor:

    /// <summary>
        /// Override the OnExecute method to perform actions when you execute the deployment plan for
        /// a database project.
        /// </summary>
        protected override void OnExecute(DeploymentPlanContributorContext context)
        {
            // determine whether the user specified a report is to be generated
            bool generateReport = false;
            string generateReportValue;
            if (context.Arguments.TryGetValue(GenerateUpdateReport, out generateReportValue) == false)
            {
                // couldn't find the GenerateUpdateReport argument, so do not generate
                generateReport = false;
            }
            else
            {
                // GenerateUpdateReport argument was specified, try to parse the value
                if (bool.TryParse(generateReportValue, out generateReport))
                {
                    // if we end up here, the value for the argument was not valid.
                    // default is false, so do nothing.
                }
            }

            if (generateReport == false)
            {
                // if user does not want to generate a report, we are done
                return;
            }

            // We output to the same directory where the deployment script
            // is output or to the current directory
            string reportPrefix = context.Options.TargetDatabaseName;
            string reportPath;
            if (string.IsNullOrEmpty(context.DeploymentScriptPath))
            {
                reportPath = Environment.CurrentDirectory;
            }
            else
            {
                reportPath = Path.GetDirectoryName(context.DeploymentScriptPath);
            }
            FileInfo summaryReportFile = new FileInfo(Path.Combine(reportPath, reportPrefix + ".summary.xml"));
            FileInfo detailsReportFile = new FileInfo(Path.Combine(reportPath, reportPrefix + ".details.xml"));

            // Generate the reports by using the helper class DeploymentReportWriter
            DeploymentReportWriter writer = new DeploymentReportWriter(context);
            writer.WriteReport(summaryReportFile);
            writer.IncludeScripts = true;
            writer.WriteReport(detailsReportFile);

            string msg = "Deployment reports ->"
                + Environment.NewLine + summaryReportFile.FullName
                + Environment.NewLine + detailsReportFile.FullName;

            ExtensibilityError reportMsg = new ExtensibilityError(msg, Severity.Message);
            base.PublishMessage(reportMsg);
        }
    /// <summary>
    /// Override the OnExecute method to perform actions when you execute the deployment plan for
    /// a database project.
    /// </summary>
        protected override void OnExecute(DeploymentPlanContributorContext context)
        {
            // determine whether the user specified a report is to be generated
            bool generateReport = false;
            string generateReportValue;
            if (context.Arguments.TryGetValue(GenerateUpdateReport, out generateReportValue) == false)
            {
                // couldn't find the GenerateUpdateReport argument, so do not generate
                generateReport = false;
            }
            else
            {
                // GenerateUpdateReport argument was specified, try to parse the value
                if (bool.TryParse(generateReportValue, out generateReport))
                {
                    // if we end up here, the value for the argument was not valid.
                    // default is false, so do nothing.
                }
            }

            if (generateReport == false)
            {
                // if user does not want to generate a report, we are done
                return;
            }

            // We output to the same directory where the deployment script
            // is output or to the current directory
            string reportPrefix = context.Options.TargetDatabaseName;
            string reportPath;
            if (string.IsNullOrEmpty(context.DeploymentScriptPath))
            {
                reportPath = Environment.CurrentDirectory;
            }
            else
            {
                reportPath = Path.GetDirectoryName(context.DeploymentScriptPath);
            }
            FileInfo summaryReportFile = new FileInfo(Path.Combine(reportPath, reportPrefix + ".summary.xml"));
            FileInfo detailsReportFile = new FileInfo(Path.Combine(reportPath, reportPrefix + ".details.xml"));

            // Generate the reports by using the helper class DeploymentReportWriter
            DeploymentReportWriter writer = new DeploymentReportWriter(context);
            writer.WriteReport(summaryReportFile);
            writer.IncludeScripts = true;
            writer.WriteReport(detailsReportFile);

            string msg = "Deployment reports ->"
                + Environment.NewLine + summaryReportFile.FullName
                + Environment.NewLine + detailsReportFile.FullName;

            DataSchemaError reportMsg = new DataSchemaError(msg, ErrorSeverity.Message);
            base.PublishMessage(reportMsg);
        }

    O método OnExecute é passado por um objeto DeploymentPlanContributorContext que fornece acesso a quaisquer argumentos especificados, o modelo de banco de dados de origem e destino, propriedades de build e arquivos de extensão. Neste exemplo, obtemos o modelo e chamamos funções auxiliares para obter informações sobre o modelo. Usamos o método auxiliar PublishMessage na classe base para relatar os erros que ocorrem.

    Outros tipos e métodos de interesse incluem: TSqlModel, ModelComparisonResult, DeploymentPlanHandle e SqlDeploymentOptions.

    Em seguida, você define a classe auxiliar que se aprofunda nos detalhes do plano de implantação.

Adicionar a classe auxiliar que gera o corpo do relatório

  • Adicione a classe auxiliar e seus métodos adicionando o seguinte código:

    /// <summary>
        /// This class is used to generate a deployment
        /// report.
        /// </summary>
        private class DeploymentReportWriter
        {
            readonly TSqlModel _sourceModel;
            readonly ModelComparisonResult _diff;
            readonly DeploymentStep _planHead;

            /// <summary>
            /// The constructor accepts the same context info
            /// that was passed to the OnExecute method of the
            /// deployment contributor.
            /// </summary>
            public DeploymentReportWriter(DeploymentPlanContributorContext context)
            {
                if (context == null)
                {
                    throw new ArgumentNullException("context");
                }

                // save the source model, source/target differences,
                // and the beginning of the deployment plan.
                _sourceModel = context.Source;
                _diff = context.ComparisonResult;
                _planHead = context.PlanHandle.Head;
            }
            /// <summary>
            /// Property indicating whether script bodies
            /// should be included in the report.
            /// </summary>
            public bool IncludeScripts { get; set; }

            /// <summary>
            /// Drives the report generation, opening files,
            /// writing the beginning and ending report elements,
            /// and calling helper methods to report on the
            /// plan operations.
            /// </summary>
            internal void WriteReport(FileInfo reportFile)
            {// Assumes that we have a valid report file
                if (reportFile == null)
                {
                    throw new ArgumentNullException("reportFile");
                }

                // set up the XML writer
                XmlWriterSettings xmlws = new XmlWriterSettings();
                // Indentation makes it a bit more readable
                xmlws.Indent = true;
                FileStream fs = new FileStream(reportFile.FullName, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
                XmlWriter xmlw = XmlWriter.Create(fs, xmlws);

                try
                {
                    xmlw.WriteStartDocument(true);
                    xmlw.WriteStartElement("DeploymentReport");

                    // Summary report of the operations that
                    // are contained in the plan.
                    ReportPlanOperations(xmlw);

                    // You could add a method call here
                    // to produce a detailed listing of the
                    // differences between the source and
                    // target model.
                    xmlw.WriteEndElement();
                    xmlw.WriteEndDocument();
                    xmlw.Flush();
                    fs.Flush();
                }
                finally
                {
                    xmlw.Close();
                    fs.Dispose();
                }
            }

            /// <summary>
            /// Writes details for the various operation types
            /// that could be contained in the deployment plan.
            /// Optionally writes script bodies, depending on
            /// the value of the IncludeScripts property.
            /// </summary>
            private void ReportPlanOperations(XmlWriter xmlw)
            {// write the node to indicate the start
                // of the list of operations.
                xmlw.WriteStartElement("Operations");

                // Loop through the steps in the plan,
                // starting at the beginning.
                DeploymentStep currentStep = _planHead;
                while (currentStep != null)
                {
                    // Report the type of step
                    xmlw.WriteStartElement(currentStep.GetType().Name);

                    // based on the type of step, report
                    // the relevant information.
                    // Note that this procedure only handles
                    // a subset of all step types.
                    if (currentStep is SqlRenameStep)
                    {
                        SqlRenameStep renameStep = (SqlRenameStep)currentStep;
                        xmlw.WriteAttributeString("OriginalName", renameStep.OldName);
                        xmlw.WriteAttributeString("NewName", renameStep.NewName);
                        xmlw.WriteAttributeString("Category", GetElementCategory(renameStep.RenamedElement));
                    }
                    else if (currentStep is SqlMoveSchemaStep)
                    {
                        SqlMoveSchemaStep moveStep = (SqlMoveSchemaStep)currentStep;
                        xmlw.WriteAttributeString("OriginalName", moveStep.PreviousName);
                        xmlw.WriteAttributeString("NewSchema", moveStep.NewSchema);
                        xmlw.WriteAttributeString("Category", GetElementCategory(moveStep.MovedElement));
                    }
                    else if (currentStep is SqlTableMigrationStep)
                    {
                        SqlTableMigrationStep dmStep = (SqlTableMigrationStep)currentStep;
                        xmlw.WriteAttributeString("Name", GetElementName(dmStep.SourceTable));
                        xmlw.WriteAttributeString("Category", GetElementCategory(dmStep.SourceElement));
                    }
                    else if (currentStep is CreateElementStep)
                    {
                        CreateElementStep createStep = (CreateElementStep)currentStep;
                        xmlw.WriteAttributeString("Name", GetElementName(createStep.SourceElement));
                        xmlw.WriteAttributeString("Category", GetElementCategory(createStep.SourceElement));
                    }
                    else if (currentStep is AlterElementStep)
                    {
                        AlterElementStep alterStep = (AlterElementStep)currentStep;
                        xmlw.WriteAttributeString("Name", GetElementName(alterStep.SourceElement));
                        xmlw.WriteAttributeString("Category", GetElementCategory(alterStep.SourceElement));
                    }
                    else if (currentStep is DropElementStep)
                    {
                        DropElementStep dropStep = (DropElementStep)currentStep;
                        xmlw.WriteAttributeString("Name", GetElementName(dropStep.TargetElement));
                        xmlw.WriteAttributeString("Category", GetElementCategory(dropStep.TargetElement));
                    }

                    // If the script bodies are to be included,
                    // add them to the report.
                    if (this.IncludeScripts)
                    {
                        using (StringWriter sw = new StringWriter())
                        {
                            currentStep.GenerateBatchScript(sw);
                            string tsqlBody = sw.ToString();
                            if (string.IsNullOrEmpty(tsqlBody) == false)
                            {
                                xmlw.WriteCData(tsqlBody);
                            }
                        }
                    }

                    // close off the current step
                    xmlw.WriteEndElement();
                    currentStep = currentStep.Next;
                }
                xmlw.WriteEndElement();
            }

            /// <summary>
            /// Returns the category of the specified element
            /// in the source model
            /// </summary>
            private string GetElementCategory(TSqlObject element)
            {
                return element.ObjectType.Name;
            }

            /// <summary>
            /// Returns the name of the specified element
            /// in the source model
            /// </summary>
            private static string GetElementName(TSqlObject element)
            {
                StringBuilder name = new StringBuilder();
                if (element.Name.HasExternalParts)
                {
                    foreach (string part in element.Name.ExternalParts)
                    {
                        if (name.Length > 0)
                        {
                            name.Append('.');
                        }
                        name.AppendFormat("[{0}]", part);
                    }
                }

                foreach (string part in element.Name.Parts)
                {
                    if (name.Length > 0)
                    {
                        name.Append('.');
                    }
                    name.AppendFormat("[{0}]", part);
                }

                return name.ToString();
            }
        }        /// <summary>
        /// This class is used to generate a deployment
        /// report.
        /// </summary>
        private class DeploymentReportWriter
        {
            /// <summary>
            /// The constructor accepts the same context info
            /// that was passed to the OnExecute method of the
            /// deployment contributor.
            /// </summary>
            public DeploymentReportWriter(DeploymentPlanContributorContext context)
            {
           }
            /// <summary>
            /// Property indicating whether script bodies
            /// should be included in the report.
            /// </summary>
            public bool IncludeScripts { get; set; }

            /// <summary>
            /// Drives the report generation, opening files,
            /// writing the beginning and ending report elements,
            /// and calling helper methods to report on the
            /// plan operations.
            /// </summary>
            internal void WriteReport(FileInfo reportFile)
            {
            }

            /// <summary>
            /// Writes details for the various operation types
            /// that could be contained in the deployment plan.
            /// Optionally writes script bodies, depending on
            /// the value of the IncludeScripts property.
            /// </summary>
            private void ReportPlanOperations(XmlWriter xmlw)
            {
            }

            /// <summary>
            /// Returns the category of the specified element
            /// in the source model
            /// </summary>
            private string GetElementCategory(IModelElement element)
            {
            }

            /// <summary>
            /// Returns the name of the specified element
            /// in the source model
            /// </summary>
            private string GetElementName(IModelElement element)
            {
            }
        }

  • Salve as alterações no arquivo de classe. Vários tipos úteis são referenciados na classe auxiliar:

    Área de código Tipos úteis
    Membros da classe TSqlModel, ModelComparisonResult, DeploymentStep
    Método WriteReport XmlWriter e XmlWriterSettings
    Método ReportPlanOperations Os tipos de interesse incluem: DeploymentStep, SqlRenameStep, SqlMoveSchemaStep, SqlTableMigrationStep, CreateElementStep, AlterElementStep, DropElementStep.

    Há várias outras etapas : consulte a documentação da API para obter uma lista completa de etapas.
    GetElementCategory TSqlObject
    ObterNomeDoElemento TSqlObject

    Em seguida, você cria a biblioteca de classes.

Assinar e compilar o assembly

  1. No menu Projeto, selecione MyDeploymentContributor propriedades.

  2. Selecione a aba Assinatura.

  3. Selecione Assinar o assembly.

  4. Em Escolher um arquivo de chave de nome forte, selecione <Novo>.

  5. Na caixa de diálogo Criar Chave de Nome Forte , no nome do arquivo chave, digite MyRefKey.

  6. (opcional) Você pode especificar uma senha para seu arquivo de chave de nome forte.

  7. Selecione OK.

  8. No menu Arquivo, selecione Salvar Tudo.

  9. No menu Build, selecione Compilar Solução.

Em seguida, você deve instalar o assembly para que ele seja carregado ao compilar e implantar projetos SQL.

Instalar um colaborador de implantação

Para instalar um colaborador de implantação, você deve copiar o assembly e o arquivo associado .pdb para a pasta Extensões.

Instalar o assembly MyDeploymentContributor

  • Em seguida, você copia as informações de montagem para o diretório de Extensões. Quando o Visual Studio é iniciado, ele identifica todas as %ProgramFiles%\Microsoft SQL Server\110\DAC\Bin\Extensions extensões no diretório e nos subdiretórios e as disponibiliza para uso:

  • Copie o MyDeploymentContributor.dll arquivo de assembly do diretório de saída para o %ProgramFiles%\Microsoft SQL Server\110\DAC\Bin\Extensions diretório. Por padrão, o caminho do arquivo compilado .dll é YourSolutionPath\YourProjectPath\bin\Debug ou YourSolutionPath\YourProjectPath\bin\Release.

Testar seu colaborador de implantação

Para testar o colaborador de implantação, você deve executar as seguintes tarefas:

  • Adicione propriedades ao .sqlproj arquivo que você planeja implantar.

  • Implante o projeto usando o MSBuild e fornecendo o parâmetro apropriado.

Adicionar propriedades ao arquivo do projeto SQL (.sqlproj)

Você sempre deve atualizar o arquivo de projeto do SQL para especificar a ID dos colaboradores que deseja executar. Além disso, como esse colaborador espera um argumento "GenerateUpdateReport", isso deve ser especificado como um argumento de colaborador.

Você pode fazer isso de duas maneiras. Você pode modificar manualmente o .sqlproj arquivo para adicionar os argumentos necessários. Você pode optar por fazer isso se o seu componente não tiver argumentos necessários para a configuração, ou se não pretende reutilizar o componente em um grande número de projetos. Se você escolher essa opção, adicione as seguintes instruções ao arquivo .sqlproj após o primeiro nó Import no arquivo.

<PropertyGroup>
    <DeploymentContributors>$(DeploymentContributors); MyDeploymentContributor.DeploymentUpdateReportContributor</DeploymentContributors>
<ContributorArguments Condition="'$(Configuration)' == 'Debug'">$(ContributorArguments);DeploymentUpdateReportContributor.GenerateUpdateReport=true;</ContributorArguments>
  </PropertyGroup>

O segundo método é criar um arquivo de destino contendo os argumentos de colaborador necessários. Isso será útil se você estiver usando o mesmo colaborador para vários projetos e tiver argumentos de colaborador necessários, já que ele inclui os valores padrão. Nesse caso, crie um arquivo de destino no caminho das extensões do MSBuild.

  1. Navegue até %ProgramFiles%\MSBuild.

  2. Crie uma nova pasta MyContributors na qual os arquivos de destino são armazenados.

  3. Crie um novo arquivo MyContributors.targets dentro desse diretório, adicione o seguinte texto a ele e salve o arquivo:

    <?xml version="1.0" encoding="utf-8"?>

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
<DeploymentContributors>$(DeploymentContributors);MyDeploymentContributor.DeploymentUpdateReportContributor</DeploymentContributors>
<ContributorArguments Condition="'$(Configuration)' == 'Debug'">$(ContributorArguments); DeploymentUpdateReportContributor.GenerateUpdateReport=true;</ContributorArguments>
  </PropertyGroup>
</Project>

  4. Dentro do arquivo .sqlproj de qualquer projeto no qual você deseje executar operações relacionadas aos colaboradores, importe o arquivo alvo adicionando a seguinte declaração ao arquivo .sqlproj após o nó <Import Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets" /> no arquivo.

    <Import Project="$(MSBuildExtensionsPath)\MyContributors\MyContributors.targets " />

Depois de seguir uma dessas abordagens, você pode usar o MSBuild para passar os parâmetros para builds de linha de comando.

Observação

Você sempre deve atualizar a propriedade "DeploymentContributors" para especificar sua ID de colaborador. Essa é a mesma ID usada no atributo "ExportDeploymentPlanExecutor" no arquivo de origem do colaborador. Sem isso, a contribuição não é invocada ao compilar o projeto. A propriedade "ContributorArguments" só precisa ser atualizada se você tiver argumentos necessários para que o colaborador seja executado.

Implantar o projeto de banco de dados

Seu projeto pode ser publicado ou implantado normalmente dentro do Visual Studio. Abra uma solução que contenha seu projeto SQL e escolha a opção "Publicar..." do menu de contexto acionado com o clique direito do mouse para o projeto, ou use F5 para uma implantação em modo de depuração no LocalDB. Neste exemplo, usamos "Publicar..." caixa de diálogo para gerar um script de implantação.

Implantar seu projeto SQL e gerar um relatório de implantação

  1. Abra o Visual Studio e abra a solução que contém seu Projeto SQL.

  2. Selecione seu projeto e clique em "F5" para fazer uma implantação de depuração. Observação: como o elemento ContributorArguments está definido para ser incluído somente se a configuração for "Depurar", por enquanto, o relatório de implantação só será gerado para implantações de depuração. Para alterar isso, remova a instrução Condition=""'$(Configuration)' == 'Debug'" da definição ContributorArguments.

  3. A saída, como o exemplo a seguir, deve estar presente na janela de saída:

    ------ Deploy started: Project: Database1, Configuration: Debug Any CPU ------
Finished verifying cached model in 00:00:00
Deployment reports ->

  C:\Users\UserName\Documents\Visual Studio 2012\Projects\MyDatabaseProject\MyDatabaseProject\sql\debug\MyTargetDatabase.summary.xml
  C:\Users\UserName\Documents\Visual Studio 2012\Projects\MyDatabaseProject\MyDatabaseProject\sql\debug\MyTargetDatabase.details.xml

  Deployment script generated to:
  C:\Users\UserName\Documents\Visual Studio 2012\Projects\MyDatabaseProject\MyDatabaseProject\sql\debug\MyDatabaseProject.sql

  4. Abra MyTargetDatabase.summary.xml e examine o conteúdo. O arquivo se assemelha ao exemplo a seguir que mostra uma nova implantação de banco de dados:

    <?xml version="1.0" encoding="utf-8" standalone="yes"?>
<DeploymentReport>
  <Operations>
    <DeploymentScriptStep />
    <DeploymentScriptDomStep />
    <DeploymentScriptStep />
    <DeploymentScriptDomStep />
    <DeploymentScriptStep />
    <DeploymentScriptStep />
    <DeploymentScriptStep />
    <DeploymentScriptStep />
    <DeploymentScriptDomStep />
    <DeploymentScriptDomStep />
    <DeploymentScriptDomStep />
    <DeploymentScriptDomStep />
    <DeploymentScriptStep />
    <DeploymentScriptDomStep />
    <BeginPreDeploymentScriptStep />
    <DeploymentScriptStep />
    <EndPreDeploymentScriptStep />
    <SqlBeginPreservationStep />
    <SqlEndPreservationStep />
    <SqlBeginDropsStep />
    <SqlEndDropsStep />
    <SqlBeginAltersStep />
    <SqlPrintStep />
    <CreateElementStep Name="Sales" Category="Schema" />
    <SqlPrintStep />
    <CreateElementStep Name="Sales.Customer" Category="Table" />
    <SqlPrintStep />
    <CreateElementStep Name="Sales.PK_Customer_CustID" Category="Primary Key" />
    <SqlPrintStep />
    <CreateElementStep Name="Sales.Orders" Category="Table" />
    <SqlPrintStep />
    <CreateElementStep Name="Sales.PK_Orders_OrderID" Category="Primary Key" />
    <SqlPrintStep />
    <CreateElementStep Name="Sales.Def_Customer_YTDOrders" Category="Default Constraint" />
    <SqlPrintStep />
    <CreateElementStep Name="Sales.Def_Customer_YTDSales" Category="Default Constraint" />
    <SqlPrintStep />
    <CreateElementStep Name="Sales.Def_Orders_OrderDate" Category="Default Constraint" />
    <SqlPrintStep />
    <CreateElementStep Name="Sales.Def_Orders_Status" Category="Default Constraint" />
    <SqlPrintStep />
    <CreateElementStep Name="Sales.FK_Orders_Customer_CustID" Category="Foreign Key" />
    <SqlPrintStep />
    <CreateElementStep Name="Sales.CK_Orders_FilledDate" Category="Check Constraint" />
    <SqlPrintStep />
    <CreateElementStep Name="Sales.CK_Orders_OrderDate" Category="Check Constraint" />
    <SqlPrintStep />
    <CreateElementStep Name="Sales.uspCancelOrder" Category="Procedure" />
    <SqlPrintStep />
    <CreateElementStep Name="Sales.uspFillOrder" Category="Procedure" />
    <SqlPrintStep />
    <CreateElementStep Name="Sales.uspNewCustomer" Category="Procedure" />
    <SqlPrintStep />
    <CreateElementStep Name="Sales.uspPlaceNewOrder" Category="Procedure" />
    <SqlPrintStep />
    <CreateElementStep Name="Sales.uspShowOrderDetails" Category="Procedure" />
    <SqlEndAltersStep />
    <DeploymentScriptStep />
    <BeginPostDeploymentScriptStep />
    <DeploymentScriptStep />
    <EndPostDeploymentScriptStep />
    <DeploymentScriptDomStep />
    <DeploymentScriptDomStep />
    <DeploymentScriptDomStep />
  </Operations>
</DeploymentReport>

    Observação

    Se você implantar um projeto de banco de dados idêntico ao banco de dados de destino, o relatório resultante não será muito significativo. Para obter resultados mais significativos, implante alterações em um banco de dados ou implante um novo banco de dados.

  5. Abra MyTargetDatabase.details.xml e examine o conteúdo. Uma pequena seção do arquivo de detalhes mostra as entradas e o script que criam o esquema Vendas, que imprimem uma mensagem sobre como criar uma tabela e que criam a tabela:

    <CreateElementStep Name="Sales" Category="Schema"><![CDATA[CREATE SCHEMA [Sales]
    AUTHORIZATION [dbo];

]]></CreateElementStep>
    <SqlPrintStep><![CDATA[PRINT N'Creating [Sales].[Customer]...';

]]></SqlPrintStep>
    <CreateElementStep Name="Sales.Customer" Category="Table"><![CDATA[CREATE TABLE [Sales].[Customer] (
    [CustomerID]   INT           IDENTITY (1, 1) NOT NULL,
    [CustomerName] NVARCHAR (40) NOT NULL,
    [YTDOrders]    INT           NOT NULL,
    [YTDSales]     INT           NOT NULL
);

]]></CreateElementStep>

    Analisando o plano de implantação conforme ele é executado, você pode relatar todas as informações contidas na implantação e pode executar mais ações com base nas etapas nesse plano.

Conteúdo relacionado

  • Last updated on