Partilhar 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. Nesta explicação passo a passo, você cria um DeploymentPlanExecutor chamado DeploymentUpdateReportContributor que cria um relatório sobre as ações executadas quando você implanta um projeto de banco de dados. Como esse colaborador de compilação 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ê precisa 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 ofereça suporte ao desenvolvimento em C# ou VB.
  • Você deve ter um projeto SQL que contém 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. Também é esperado que você esteja familiarizado com conceitos básicos do Visual Studio, como 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 as referências necessárias.

  • Defina uma classe chamada DeploymentUpdateReportContributor que herda de DeploymentPlanExecutor.

  • Substitua o método OnExecute.

  • Adicione uma classe auxiliar particular.

  • Construa a montagem resultante.

Criar um projeto de biblioteca de classes

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

  2. Renomeie o arquivo "Class1.cs" para "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 Frameworks.

  5. Adicionar referências 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:\Program Files (x86)\Microsoft SQL Server\110\DAC\Bin . Escolha as entradas Microsoft.SqlServer.Dac.dll, Microsoft.SqlServer.Dac.Extensions.dlle Microsoft.Data.Tools.Schema.Sql.dll, selecione Adicionar e, em seguida, selecione OK.

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

Definir a classe DeploymentUpdateReportContributor

  1. No editor de códigos, atualize o arquivo DeploymentUpdateReportContributor.cs para corresponder aos seguintes 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 definiu o seu colaborador de implementação que herda de DeploymentPlanExecutor. Durante os processos de construção e desdobramento, os componentes personalizados são carregados de um diretório de extensão padrão. Os contribuidores 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")]

    Neste 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, substitua o método OnExecute para adicionar o código que deseja executar quando um projeto de banco de dados é implantado.

Substituir OnExecute

  • Adicione o seguinte método à sua 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 recebe um objeto DeploymentPlanContributorContext que fornece acesso a quaisquer argumentos especificados, ao modelo de banco de dados de origem e destino, propriedades de compilação e arquivos de extensão. Neste exemplo, obtemos o modelo e, em seguida, chamamos funções auxiliares para produzir informações sobre o modelo. Usamos o método auxiliar PublishMessage na classe base para relatar quaisquer erros que ocorram.

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

    Em seguida, você define a classe auxiliar que analisa os 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 turma 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.
    ObterCategoriaDoElemento TSqlObject
    GetElementName TSqlObject

    Em seguida, você cria a biblioteca de classes.

Assine e construa a montagem

  1. No menu Projeto , selecione Propriedades de MyDeploymentContributor.

  2. Selecione a guia Assinatura .

  3. Selecione Assinar a montagem.

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

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

  6. (facultativo) 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 Compilação, selecione Compilar Solução.

Em seguida, deve instalar o assembly para que seja carregado ao construir e implementar 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, copie as informações do assembly para o diretório 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 subdiretórios e as disponibiliza para uso:

  • Copie o MyDeploymentContributor.dll arquivo 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.

Teste seu colaborador de implantação

Para testar seu 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 de projeto SQL (.sqlproj)

Você sempre deve atualizar o arquivo de projeto 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 colaborador não tiver nenhum argumento de colaborador necessário para a configuração ou se você não pretende reutilizar o colaborador em um grande número de projetos. Se optar por esta opção, adicione as seguintes declaraçõ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 destinos contendo os argumentos de contribuidor necessários. Isso é útil se você estiver usando o mesmo colaborador para vários projetos e tiver argumentos de contribuidor necessários, pois inclui os valores padrão. Nesse caso, crie um arquivo de destinos no caminho de extensões do MSBuild.

  1. Navegue até %ProgramFiles%\MSBuild.

  2. Crie uma nova pasta MyContributors onde os arquivos de destino estão armazenados.

  3. Crie um novo arquivo MyContributors.targets dentro deste 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 .sqlproj ficheiro de qualquer projeto que pretenda gerir contribuidores, importe o ficheiro de targets ao adicionar a seguinte instrução ao .sqlproj ficheiro após o <Import Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets" /> nó no ficheiro:

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

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

Observação

Você sempre deve atualizar a propriedade "DeploymentContributors" para especificar sua ID de colaborador. Este é o mesmo ID usado no atributo "ExportDeploymentPlanExecutor" no arquivo de origem do colaborador. Sem isto, o teu colaborador não é executado quando compilas o projeto. A propriedade "ContributorArguments" precisa ser atualizada somente se você tiver argumentos necessários para que seu 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..." no menu de contexto do botão direito do mouse para o projeto ou use F5 para uma implantação de depuração no LocalDB. Neste exemplo, usamos o "Publicar..." para gerar um script de implantação.

Implante seu projeto SQL e gere 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. Nota: como o elemento ContributorArguments está definido para ser incluído apenas se a configuração for "Debug", de momento o relatório de implementação só é gerado para implementações de teste. 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 é semelhante 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 Sales, que imprimem uma mensagem sobre a criação de 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>

    Ao analisar o plano de implantação à medida que ele é executado, você pode relatar qualquer informação contida na implantação e pode tomar mais ações com base nas etapas desse plano.

Conteúdo relacionado

  • Last updated on