Procédure pas à pas : débogage d'un agrégat SQL CLR défini par l'utilisateur

Mise à jour : novembre 2007

Cette rubrique s'applique à :

Édition	Visual Basic	C#	C++	Web Developer
Express
Standard
Pro et Team

Légende du tableau :

	Applicable
	Non applicable
	Commande ou commandes masquées par défaut.

Cet exemple montre comment déboguer un agrégat CLR SQL défini par l'utilisateur. Il crée une fonction d'agrégation CLR SQL nommée Concaténer dans l'exemple de base de données AdventureWorks. Lorsque cette fonction est appelée dans une instruction SQL, elle concatène toutes les valeurs de la colonne spécifiée pour être son paramètre d'entrée.

Remarque :
Les boîtes de dialogue et les commandes de menu qui s'affichent peuvent être différentes de celles qui sont décrites dans l'aide, en fonction de vos paramètres actifs ou de l'édition utilisée. Pour modifier vos paramètres, choisissez Importation et exportation de paramètres dans le menu Outils. Pour plus d'informations, consultez Paramètres Visual Studio.

Pour déboguer une fonction d'agrégation CLR SQL

1. Dans un nouveau projet SQL Server, établissez une connexion à l'exemple de base de données AdventureWorks. Pour plus d'informations, consultez Comment : se connecter à une base de données.

2. Créez une fonction à l'aide du code contenu dans la première section d'exemples suivante et nommez-la Concatenate.cs. Pour plus d'informations, consultez Comment : développer avec le type de projet SQL Server.

3. Ajoutez un script qui teste la fonction en l'incluant dans une instruction SELECT. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le répertoire TestScripts, puis sélectionnez Ajouter un script de test et insérez le code de la deuxième section d'exemple de cette visite guidée. Enregistrez le fichier avec le nom Concatenate.sql. Cliquez avec le bouton droit sur le nom du fichier, puis cliquez sur Définir comme script de débogage par défaut.

4. Placez un point d'arrêt dans Concatenate.cs à l'intérieur de la méthode Accumulate sur l'instruction if. Pour cela, cliquez dans la marge de gauche grisée de la fenêtre Éditeur de texte, et dans le menu Déboguer, cliquez sur Démarrer pour compiler, déployer et effectuer un test unitaire du projet. L'apparition du pointeur d'instruction (désigné par une flèche jaune) sur le point d'arrêt signifie que vous êtes en train de déboguer votre fonction.

5. Testez différentes fonctionnalités de débogage.

   1. La méthode Accumulate s'exécute une fois pour chaque ligne de la clause GROUP BY du script dans Concatenate.sql. En cliquant à plusieurs reprises sur Pas à pas détaillé dans le menu Déboguer, vous pouvez surveiller la façon dont le résultat de la méthode est généré.

   2. Dans la fenêtre Variables locales, ouvrez la variable value qui contient le nom du magasin en cours de traitement.

   3. Cliquez sur la variable this. Le nœud enfant intermediateResult sera retourné par cette fonction, contenant tous les noms de magasins jusqu'au nom actuel, concaténés et séparés par des virgules.

   4. Dans l'Éditeur de texte, double-cliquez sur la variable intermediateResult pour la sélectionner. Faites glisser intermediateResult vers la fenêtre Espion et déposez-la n'importe où dans la fenêtre. La variable est désormais ajoutée à la liste des variables espionnées.

   5. Effectuez un pas à pas dans la méthode plusieurs fois. La valeur de intermediateResult changera à chaque fois avec la méthode, avec un nom de magasin supplémentaire concaténé à la fin.

   6. Cliquez sur le point d'arrêt pour le supprimer et ajoutez un point d'arrêt à la première instruction à l'intérieur de la méthode Terminate. Cette méthode retourne le résultat à l'appelant. Pour effectuer un pas à pas détaillé dans ce code, dans le menu Déboguer, cliquez sur Démarrer. Vous pouvez maintenant effectuer un pas à pas détaillé en cliquant sur Pas à pas détaillé dans le menu Déboguer. Arrêtez-vous lorsque vous atteignez l'instruction return.

   7. Cliquez de nouveau sur Continuer pour terminer de déboguer la fonction.

Exemple

Voici le code de la fonction d'agrégation utilisée dans cet exemple.

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

Voici le script de test qui appelle la fonction.

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

Voir aussi

Tâches

Comment : créer et exécuter un agrégat SQL Server CLR

Autres ressources

Débogage d'une base de données SQL CLR