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

Le informazioni contenute in questo argomento sono valide per:

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

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

Se quando si tenta di eseguire il debug di un oggetto CLR SQL, viene visualizzato il messaggio "Operazione annullata dall'utente", è necessario configurare manualmente sia il computer in cui viene eseguito Visual Studio sia il computer in cui è in esecuzione SQL Server. Per ulteriori informazioni, vedere Procedura: configurare i computer per l'abilitazione del debug di CLR SQL e Transact-SQL.

Nota

È possibile che le finestre di dialogo e i comandi di menu visualizzati siano diversi da quelli descritti nella Guida a seconda delle impostazioni attive o dell'edizione del programma. Per modificare le impostazioni, scegliere Importa/Esporta impostazioni dal menu Strumenti. Per ulteriori informazioni, vedere la classe Gestione delle impostazioni.

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

1. In un nuovo progetto CLR SQL stabilire una connessione al database di esempio AdventureWorks. Per ulteriori informazioni, vedere How to: Connect to a Database.

2. Creare una nuova funzione utilizzando il codice della prima sezione di esempi e denominarla Concatenate.cs. Per ulteriori informazioni, vedere How to: Develop with the SQL Server Project Type.

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.cs all'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. Il metodo Accumulate viene eseguito una volta per ognuna delle righe che costituiscono la clausola GROUP BY nello script incluso in Concatenate.sql. Scegliendo ripetutamente Esegui istruzione dal menu Debug è possibile osservare come viene compilato il risultato del metodo.

   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 da cui viene chiamata 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 SQL Server tramite l'integrazione di Common Language Runtime