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

Este tópico se aplica a:

Edition	Visual Basic	C#	C++	Desenvolvedores Web
Express
Standard
Pro e equipe

Este exemplo mostra como depurar um SQL Server Common Language Runtime (CLR SQL) definidos pelo usuário agregado. Ele cria uma nova função agregada CLR de SQL chamada concatenar na 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.

Se, quando você tentar depurar um objeto CLR em SQL, a mensagem "Cancelada pelo usuário" aparece, você deve configurar manualmente o computador no qual você está executando Visual Studio , bem como o computador que está executando o SQL Server. Para obter mais informações, consulte Como: Configurar seus computadores para habilitar o Transact-SQL e depuração de CLR de SQL.

Observação
As caixas de diálogo e comandos de menu demonstradas podem ser diferentes daqueles descritos na Ajuda, dependendo das configurações ativas ou configurações de edição. Para alterar as configurações, escolha Import and Export Settings sobre o Ferramentas menu. Para obter mais informações, consulte Trabalhando com configurações.

Para depurar uma função agregada do CLR SQL

1. Em um novo projeto de SQL de CLR, estabelecer uma conexão com o AdventureWorks banco de dados de exemplo. Para obter mais informações, consulte How to: Connect to a Database.

2. Crie uma nova função usando o código do primeiro o exemplo a seguir, seções e o nome Concatenate.cs. Para obter mais informações, consulte How to: Develop with the SQL Server Project Type.

3. Adicionar um script que testa a função incluindo-o em um SELECT instrução. Em Solution Explorer, com o botão direito do TestScripts directory, selecione Add Test Scripte insira o código da segunda seção do exemplo nesta explicação. Salve o arquivo com o nome Concatenate.sql. Clique com o botão direito no nome do arquivo e clique em Set as Default Debug Script.

4. Colocar um ponto de interrupção Concatenate.cs dentro do Accumulate método o if instrução. Para fazer isso, clique na margem esquerda sombreada da janela do Editor de texto e, no Debug menu, clique em Iniciar para compilar, implantar e o projeto de teste de unidade. 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. O Accumulate método é executado uma vez para cada linha que constitui a GROUP BY cláusula do script em Concatenate.sql. Clicando-se repetidamente Step Into da Debug menu, você pode observar como o resultado do método é criado.

   2. No Locals janela, abra a variável value, que contém o nome do armazenamento atual que está sendo processado.

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

   4. No editor de texto, clique duas vezes o intermediateResult variável para selecionar um proprietário. Arraste intermediateResult para o Watch janela e solte-o em qualquer lugar na janela. A variável agora é adicionada à lista de variáveis observadas.

   5. Percorra o método várias vezes. O valor de intermediateResult será alterada sempre que através do método, com um nome de armazenamento adicionais concatenado no final.

   6. Clique no ponto de interrupção para removê-lo e, em seguida, adicionar um ponto de interrupção para a primeira instrução dentro do Terminate método. Esse método retorna o resultado para o chamador. Para entrar, na Debug menu, clique em Iniciar. Você pode agora passar através dele, clicando em Step Into sobre o Debug menu. Parar quando você acerta o return instrução.

   7. Clique em continuar novamente para concluir a depuração da função.

Exemplo

Este é o código para a função agregada 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 um agregado de SQL Server usando a integração do Common Language Runtime