Demonstra Passo a passo: depuração uma agregação de SQL CLR definida pelo usuário

Este tópico se aplica a:

Edição	Visual Basic	C#	C++	Desenvolvedores Web
Express
Padrão
PRO e equipe

Legenda de tabela:

	Aplica-se
	Não é aplicada
	Comando ou comandos oculta por padrão.

Este exemplo mostra como depurar uma agregação de CLR SQL definida pelo usuário.Ele cria uma nova função de agregação do CLR SQL chamada CONCATENAR in the AdventureWorks banco de dados de exemplo.Quando essa função é chamado em uma Instrução SQL, ela irá concatenar todos os valores para a coluna especificada como seu parâmetro de entrada.

Observação:
As caixas de diálogo e comandos de menu demonstradas podem ser diferentes daqueles descritas na Ajuda, dependendo das configurações ativas ou configurações de edição.Para alterar as configurações, escolher Importar e exportar configurações on the Ferramentas menu.Para obter mais informações, consulte Configurações do Visual Studio.

Para depurar uma função de agregação CLR SQL

1. Em um novo projeto SQL servidor, estabelecer uma conexão com a AdventureWorks banco de dados de exemplo.Para obter mais informações, consulte Como: Conectar-se a um banco de dados.

2. Crie uma nova função usando o código do primeiro exemplo a seguir seções e nomeie-concatenar.cs.Para obter mais informações, consulte Como: Desenvolver com o SQL servidor tipo de projeto.

3. Adicionar um script que testa a função incluindo-o em um SELECT demonstrativo. In O gerenciador de soluções, clicar com o botão direito do mouse o TestScripts diretório, selecionar Adicionar script de teste e inserir o código da segunda seção do exemplo nesta explicação passo a passo.salvar o arquivo com o nome concatenar.sql.clicar com o botão direito do mouse no nome de arquivo e, em seguida, clique em conjunto sistema autônomo padrão o script de depurar.

4. Coloque um ponto de interrupção no concatenar.cs dentro do Accumulate método na if demonstrativo. Para fazer isso, clicar na margem esquerda sombreada da janela do Editor de texto e no Depurar menu, clicar Iniciar para compilar, implantar e unidade de teste do projeto.Quando o ponteiro de instrução, designado por uma seta amarela, aparecer no ponto de interrupção, você está depurando sua função.

5. Tente diferentes recursos de depuração.

   1. The Accumulate método é executado uma vez para cada linha que constitui a GROUP BY cláusula do script em concatenar.sql. Ao clicar repetidamente Passar dentro from the Depurar menu, você pode observar como o resultado do método é criado.

   2. No Variáveis locais janela, abra a variável value, que contém o nome do armazenamento corrente que está sendo processado.

   3. clicar na variável this. O filho nó intermediateResult será retornado dessa função e contém todos os nomes de armazenamento até o corrente um concatenadas e separados por vírgulas.

   4. No editor de texto, clicar duas vezes o intermediateResult variável para selecioná-lo. arrastar intermediateResult para o inspeção janela e solte-o em qualquer local na janela.A variável agora é adicionada à lista de variáveis observadas.

   5. Depurar o método várias vezes.O valor de intermediateResult será alterada sempre que através do método com adicional armazenar nome concatenado no participante.

   6. clicar o ponto de interrupção para removê-lo e adicione um ponto de interrupção para a primeira demonstrativo dentro de Terminate método. Esse método retorna o resultado para o chamador.Entrar em, sobre o Depurar menu, clicar Iniciar.Você pode agora percorrê-lo clicando em Passar dentro on the Depurar menu.Parar quando você acerta o return demonstrativo.

   7. clicar Continuar novamente para concluir a depuração da função.

Exemplo

Esse é o código para a função de agregação usada neste exemplo.

using System;
using System.Data.Sql;
using System.Data.SqlTypes;
using Microsoft.SqlServer.Server;
using System.IO;
using System.Text;
[Serializable]
[SqlUserDefinedAggregate( 
    //use CLR serialization to serialize the intermediate result. 
    Format.UserDefined, 
    //Optimizer property: 
    IsInvariantToNulls=true,
    //Optimizer property: 
    IsInvariantToDuplicates=false,
    //Optimizer property: 
    IsInvariantToOrder=false,
    //Maximum size in bytes of persisted value: 
    MaxByteSize=8000)
] 
public class Concatenate: IBinarySerialize 
{ 
    /// <summary> 
    /// Variable holds intermediate result of the concatenation 
    /// </summary> 
    private StringBuilder intermediateResult; 
    /// <summary> 
    /// Initialize the internal data structures 
    /// </summary> 
    public void Init( ) 
    { 
        intermediateResult = new StringBuilder(); 
    } 
    /// <summary> 
    /// Accumulate the next value, nop if the value is null 
    /// </summary> 
    /// <param name="value"></param> 
    public void Accumulate(SqlString value) 
    { 
        if(value.IsNull) 
        { 
            return; 
        } 
        intermediateResult.Append(value.Value).Append(','); 
    } 
    /// <summary> 
    /// Merge the partially computed aggregate with this aggregate. 
    /// </summary> 
    /// <param name="other"></param> 
    public void Merge( Concatenate other) 
    { 
        intermediateResult.Append(other.intermediateResult); 
    } 
    /// <summary> 
    /// Called at end of aggregation, to return results. 
    /// </summary> 
    /// <returns></returns> 
    public SqlString Terminate() 
    { 
        string output = string.Empty; 
        //Delete the trailing comma, if any .
        if (intermediateResult != null && intermediateResult.Length > 0) 
            output = intermediateResult.ToString(0, intermediateResult.Length-1); 
        return new SqlString(output); 
    } 
    public void Read(BinaryReader r) 
    { 
        intermediateResult = new StringBuilder(r.ReadString()); 
    } 
    public void Write(BinaryWriter w) 
    { 
        w.Write(intermediateResult.ToString()); 
    } 
}

Este é o script de teste que chama a função.

SELECT scu.SalesPersonID, dbo.Concatenate(sst.Name)
FROM Sales.Customer as scu 
INNER JOIN Sales.Store as sst
    ON scu.CustomerID    = sst.CustomerID
INNER JOIN Sales.SalesPerson as spr
    ON scu.SalesPersonID = spr.SalesPersonID
WHERE    scu.SalesPersonID = 283
GROUP BY scu.SalesPersonID

Consulte também

Tarefas

Como: Criar e executar uma CLR SQL Server agregação

Outros recursos

Depuração de banco de dados SQL CLR