Procedura dettagliata: esecuzione del debug di un aggregato CLR SQL definito dall'utente

Aggiornamento: novembre 2007

Le informazioni contenute in questo argomento sono valide per:

Edition	Visual Basic	C#	C++	Web Developer
Express
Standard
Pro e Team

Legenda tabella:

	Applicabile
	Non applicabile
	Comando o comandi nascosti per impostazione predefinita.

Nell'esempio riportato di seguito viene illustrato come eseguire il debug di un'aggregazione CLR/SQL definita dall'utente. Nel database di esempio AdventureWorks viene creata una nuova funzione di aggregazione CLR/SQL denominata Concatenate. Quando questa funzione viene richiamata in un'istruzione SQL, vengono concatenati tutti i valori per la colonna specificata come relativo parametro di input.

Nota:
Le finestre di dialogo e i comandi di menu visualizzati potrebbero non corrispondere a quelli descritti nella Guida in linea in quanto dipendono dall'edizione o dalle impostazioni attive. Per modificare le impostazioni, scegliere Importa/esporta impostazioni dal menu Strumenti. Per ulteriori informazioni, vedere Impostazioni di Visual Studio.

Per eseguire il debug di una funzione di aggregazione CLR/SQL

1. In un nuovo progetto SQL Server stabilire una connessione al database di esempio AdventureWorks. Per ulteriori informazioni, vedere la classe Procedura: connettersi a un database.

2. Creare una nuova funzione utilizzando il codice della prima sezione di esempi e denominarla Concatenate.cs. Per ulteriori informazioni, vedere Procedura: sviluppare con il tipo di progetto SQL Server.

3. Aggiungere uno script che provi la funzione includendola in un'istruzione SELECT. In Esplora soluzioni fare clic con il pulsante destro del mouse sulla directory Script di test, selezionare Aggiungi script di test e inserire il codice della seconda sezione di esempi contenuta in questa procedura dettagliata. Salvare il file con il nome Concatenate.sql. Fare clic con il pulsante destro del mouse sul nome del file, quindi scegliere Imposta come script di debug predefinito.

4. Inserire un punto di interruzione in Concatenate.csall'interno del metodo Accumulate in corrispondenza dell'istruzione if. A tale scopo, fare clic sul margine sinistro ombreggiato della finestra dell'editor di testo e scegliere Avvia dal menu Debug per compilare e distribuire il progetto nonché per eseguirne l'unit test. Quando il puntatore all'istruzione, indicato da una freccia gialla, compare su un punto di interruzione, è in corso il debug della funzione.

5. Provare altre funzionalità di debug.

   1. The Accumulate method is executed one time for each row that makes up the GROUP BY clause in the script in Concatenate.sql. By repeatedly clicking Step Into from the Debug menu, you can watch how the method result is built.

   2. Nella finestra Variabili locali aprire la variabile value contenente il nome dell'archivio corrente in corso di elaborazione.

   3. Fare clic sulla variabile this. Il nodo figlio intermediateResult viene restituito da questa funzione e contiene tutti i nomi di archivio fino a quello corrente concatenati e separati da virgole.

   4. Nell'editor di testo fare doppio clic sulla variabile intermediateResult per selezionarla. Trascinare intermediateResult nella finestra Espressioni di controllo e rilasciarla in un punto qualsiasi. La variabile verrà aggiunta all'elenco delle variabili di controllo.

   5. Eseguire il metodo più volte istruzione dopo istruzione. Il valore di intermediateResult cambierà ogni volta che viene eseguito il metodo e ogni volta alla fine verrà concatenato un nome di archivio aggiuntivo.

   6. Fare clic sul punto di interruzione per rimuoverlo, quindi aggiungere un punto di interruzione alla prima istruzione all'interno del metodo Terminate. Il metodo restituisce il risultato al chiamante. Per eseguirne le istruzioni, scegliere Avvia dal menu Debug. A questo punto, scegliere Esegui istruzione dal menu Debug per eseguire il metodo istruzione dopo istruzione. Interrompere l'esecuzione quando si raggiunge l'istruzione return.

   7. Scegliere nuovamente Continua per terminare il debug della funzione.

Esempio

Codice per la funzione di aggregazione utilizzata nell'esempio.

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()); 
    } 
}

Script di prova che chiama la funzione.

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

Vedere anche

Attività

Procedura: creare ed eseguire un aggregato CLR di SQL Server

Altre risorse

Esecuzione del debug di database CLR SQL