Présentation de SQL Server 2005

SQL Configuration Manager est l'utilitaire qui vous permet de configurer, simplement et rapidement, votre serveur SQL.

Voici un aperçu de son interface graphique :

Et voici la page de configuration des propriétés :

Comme vous pouvez le voir, rien de bien compliqué en soi, surtout si vous aviez déjà utilisé une précédente version de SQL Server.

En effet, c'est dans cette partie que vous pourrez démarrer, arrêter ou bien redémarrer votre instance de SQL Server.

Voici l'écran principal de cet outil destiné, lui aussi, à paramétrer certaines options de votre serveur SQL :

Voyons chaque partie un peu plus en détail.

IV-B-1. Surface Area Configuration for Services and Connections▲

Sur cet écran, vous aurez la possibilité de configurer les services et les connexions qui seront nécessaires pour vos applications.

Voici l'écran que vous utiliserez pour configurer les services :

Et voici la partie que vous utiliserez si vous souhaitez configurer les connexions à utiliser pour vos applications.

Vous avez la possibilité de choisir deux types de connexions :

• connexions locales uniquement ;
• connexions locales et distantes (en indiquant le type de protocole que vous voulez utiliser).

Voici une image qui vous permettra de mieux comprendre tout cela :

IV-B-2. Surface Area Configuration for Features▲

Surface Area Configuration for Features est l'utilitaire qui vous permettra de configurer les options de votre Serveur SQL, que vous voulez utiliser.

En effet, c'est ici que vous indiquerez si, pour une certaine instance de SQL Serveur, vous souhaitez activer l'intégration de la CLR (Common Language RunTime) (qui vous permet d'écrire du code .NET dans SQL Serveur), Surface Area Configuration for Features ou bien si vous souhaitez activer Database Mail, le nouveau composant de SQL Server 2005, qui vous permet d'envoyer des e-mails depuis SQL Server, en utilisant un serveur SMTP.

Bref, vous pourrez, via ce menu, activer ou désactiver beaucoup d'options pour votre instance SQL Server, selon que vos applications utilisent ou non ces options.

Dès lors que vous lancez SQL Server Express Manager, celui-ci vous demande des informations de connexion, afin de vous logger au serveur SQL.
Vous devez donc indiquer :

• le nom de l'instance du serveur (attention, vous devez également préciser le nom du serveur sur lequel est exécutée cette instance. Par exemple, dans mon cas, il me faut indiquer WIN2K3\SQLExpress comme nom d'instance du serveur SQL) ;
• le type d'authentification : c'est à ce moment que vous allez spécifier si vous voulez vous connecter en utilisant un utilisateur Windows ou un utilisateur du serveur SQL ;
• les logins/mot de passe nécessaires à la connexion.

Voici donc à quoi ressemble cet écran :

Une fois la connexion réussie, vous vous retrouvez dans la partie principale de SQL Server Express Manager. C'est ici que vous pourrez réaliser la plupart des opérations de gestion (ajout/suppression de base de données, etc.).

N'oubliez pas qu'il s'agit encore d'une version BETA, donc toutes les fonctionnalités ne sont pas forcément encore implémentées.

Le volet gauche de l'application contient la liste de toutes les bases de données système installées, ainsi que tous les comptes du serveur SQL, tandis que le volet de droite contient une zone de texte vous permettant de saisir vos requêtes SQL.

Vous pouvez également voir, en haut de l'arborescence de la partie gauche, l'instance SQL à laquelle vous êtes connecté, son numéro de version ainsi que le nom d'utilisateur utilisé pour la connexion.

Pour créer une nouvelle base de données, faites un clic droit, dans le panneau de gauche, sur «  Databases » et choisissez «  New Database ».

À ce moment-là, le côté droit de l'application affichera un nouvel onglet dans lequel vous devrez spécifier le nom et l'emplacement de la base de données que vous voulez créer.

Une fois créée, votre nouvelle base de données apparaît dans la liste de gauche, en dessous des «  System Databases ».

Comme vous le voyez, créer une base de données est donc extrêmement simple.

Vous pouvez afficher les propriétés de votre base de données en faisant un clic droit sur son nom et en choisissant «  Properties ».

Pour exécuter des requêtes SQL sur votre base de données, vous devez :

• sélectionner la base de données sur laquelle vous voulez travailler (en utilisant la ComboBox située en haut à droite ou en utilisant la requête SQL : use la_base_de_donnee) ;
• écrire le code de votre requête SQL ;
• appuyer sur Ctrl+F5 pour parser votre requête SQL et vous assurer qu’elle ne comporte pas d'erreurs ;
• appuyer sur F5 pour exécuter votre requête SQL.

Et votre requête SQL est exécutée sur le serveur.

Comme vous pouvez le voir, la visualisation du résultat est immédiate dans l'arborescence de gauche et l'on distingue visuellement les différentes colonnes de la table (clé primaire, clés étrangères, etc.).

Pour ajouter une nouvelle connexion à la source de données, rien de plus simple :

• ouvrez Visual Studio 2005 ;
• cliquez sur «  Tool » puis «  Connect to Database » ;
• choisissez «  Microsoft SQL Server » puis cliquez sur «  OK » ;
• entrez (ou choisissez, via la liste déroulante) le nom de l'instance à laquelle vous souhaitez vous connecter ;
• saisissez les informations de connexion (login et mot de passe) ;
• sélectionnez la base de données à utiliser ;
• cliquez sur «  OK ».

Un clic sur le bouton «  Test Connection » vous permet de vous assurer que la connexion au serveur SQL se fait sans problème.

Si tout s'est déroulé correctement, vous devriez voir apparaître, dans votre «  Server Explorer », une nouvelle connexion, sous le nœud «  Data Connections ».

Maintenant que cette source de données est ajoutée, voyons comment nous pouvons travailler avec dans Visual Studio.

Pour vous expliquer comment utiliser cette nouvelle connexion, le mieux est sans doute de vous faire une démonstration.

Il y aura en fait deux projets :

• un projet de type «  WindowsForms », qui vous montrera surtout les nouvelles fonctionnalités d'ADO.NET 2.0 ;
• un projet de type «  SQL Server Project », qui vous montrera comment développer vos propres fonctions, procédures stockées, etc. pour SQL Server directement depuis votre code .NET.

Voici donc la première démonstration

Nous allons donc choisir, dans Visual Studio, de faire un nouveau projet de type Windows Application.

Ensuite, nous ajoutons à notre interface quelques composants graphiques :

• une GroupeBox ;
• une DataGridView (nouveau composant, qui remplace le DataGrid) ;
• un bouton d'enregistrement ;
• un bouton d'annulation ;
• un bouton d'effacement de la DataGridView ;
• un bouton de rechargement de la DataGridView.

Enfin, nous mettons une nouvelle source de données à notre projet, qui va automatiquement nous ajouter :

• un dataset ;
• une BindingSource ;
• un DataTableAdapter.

Nous pouvons maintenant nous concentrer sur le code .NET.

Voici, par exemple, le code qui se trouve derrière le bouton de rechargement de la DataGridView :

private void btnReload_Click(object sender, EventArgs e)
{
     // On remplit le DataSet
     this.dotnetTableAdapter.Fill(this.dBDotnetDataSet.dotnet);

     // On remplit l'affichage de la grille
     this.dotnetBindingSource.DataSource = this.dBDotnetDataSet;
     this.dgview.DataSource = this.dotnetBindingSource;
}

Ici, on se contente de remplir le DataSet au moyen de la méthode Fill de notre DataAdapter. Ensuite, nous associons la DataSource de notre BindingSource à notre DataSet, puis il ne nous reste plus qu'a «  binder » (associer) la source de données (DataSource) de notre DataGridView à notre BindingSource.

Pour simplifier, dites-vous que ce code sert à remplir un DataSet, puis à utiliser ce DataSet comme source de données de notre DataGridView.

Voyons maintenant le code qui se cache derrière le bouton d'enregistrement des données :

private void btnSave_Click(object sender, EventArgs e)
{
    if (MessageBox.Show(String.Format(null, "Êtes-vous sûr de vouloir mettre à jour la base de données ?"), 
    String.Format(null, "Mise à jour"), MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
    {
        // Si le DataSet a été modifié
        if (this.dBDotnetDataSet.HasChanges())
        {
            // On met à jour la base de données en utilisant la DataTable et le TableAdapter
            int i = this.dotnetTableAdapter.Update(this.dBDotnetDataSet);

            MessageBox.Show(String.Format(null, "{0} lignes ont été mises à jour dans la base de données", i.ToString()), 
            String.Format("Mise à jour"), MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
    }
    else
    {
        return;
    }
}

Si vous avez déjà travaillé avec ADO.NET, ce code devrait vous être très familier.

En effet, ici, nous demandons à l'utilisateur de valider (ou non) la sauvegarde des modifications effectuées dans la grille. Si le choix est oui, alors nous nous assurons que le DataSet a bien été modifié (au moyen de la méthode HasChanges),puis nous mettons à jour la base de données de manière très simple : en appelant la méthode Update du DataAdapter.

C'est cette méthode qui va se charger de tout (c'est-à-dire faire les INSERT, les UPDATE, les DELETE, etc.).

Le résultat en image :

Et pour vous montrer que le résultat a bien été pris en compte dans la base de données, vous avez plusieurs choix :

• relancer l'application pour refaire un chargement des données ;
• cliquer sur le bouton de mise à jour de la DataGridView ;
• aller voir directement les données qui se trouvent dans la base.

Pour vous montrer le résultat, j'ai utilisé la troisième possibilité, et voici le résultat :

Les données apparaissent bien modifiées dans la base (dans mon cas, il s'agit d'une ligne qui a été ajoutée).

Passons maintenant à la deuxième démonstration.

Deuxième démonstration

Ici, je vous montrerai un peu plus en détail comment créer votre propre fonction, pour SQL Server, en utilisant du code .NET.

Commencez par lancer Visual Studio, puis choisissez de faire un nouveau projet. Là, choisissez un projet de type «  Database » et, dans les templates prédéfinis, choisissez «  SQL Server Project ».

Visual Studio vous demandera alors quelle connexion SQL vous souhaitez utiliser dans votre projet : vous pouvez alors en créer une nouvelle ou utiliser une connexion déjà existante.

À partir de là, vous vous retrouvez dans Visual Studio, mais, contrairement à l'habitude, aucune feuille de code n'est déjà ouverte.

En effet, c'est à vous d'ajouter, à votre projet, un nouvel item : cela se fait en cliquant droit sur le nom de votre projet, et en choisissant «  Add » puis «  New Item ».

À ce moment-là, sélectionnez le type d'item que vous voulez ajouter (dans notre cas, nous sélectionnons «  User-Defined Function »), donnez-lui un nom puis cliquez sur «  Add ».

Et là, vous vous retrouvez devant une feuille de code qu'il va vous falloir compléter.
Avant toute chose, prenez note de l'attribut situé au-dessus de la fonction Main :

[Microsoft.SqlServer.Server.SqlFunction]

Bien entendu, il y a d'autres attributs, tels que SqlTrigger, SqlMethod, SqlFunction, etc.

Le paramètre DataAccess=DataAccessKind.Read permet de spécifier que l'on va juste lire des données depuis la base.

Voici donc le code complet (et, je l'espère suffisamment expliqué) de notre fonction :

[Microsoft.SqlServer.Server.SqlFunction(DataAccess=DataAccessKind.Read)]
public static SqlString GetCommentFromId(int id)
{
    // Instanciation d'un nouvel objet de type SqlConnection
    // Context Connection=True est le seul paramètre que vous devez ajouter
    // lorsque vous développez des projets de type SQL Server Projects
    SqlConnection cnx = new SqlConnection(@"Context Connection=True");

    // Instanciation d'un nouvel objet de type SqlCommand
    SqlCommand cmd = new SqlCommand();

    cmd.Connection = cnx;

    // On définit la requête à exécuter
    cmd.CommandText = "SELECT chaine FROM dotnet WHERE dotnet_id = @idparam";

    // On ajoute le paramètre à la requête
    // AddWithValue = Nouvelle méthode permettant l'ajout direct d'un paramètre
    // et de sa valeur
    cmd.Parameters.AddWithValue("@idparam", id);

    // Ouverture de la connexion
    cnx.Open();

    // On exécute la requête et on récupère le résultat
    string comment = (string) cmd.ExecuteScalar();

    // Fermeture de la connexion
    cnx.Close();

    // On renvoie le résultat
    return comment;
}

Les développeurs .NET ne seront, une fois de plus, pas dépaysés par un tel code. Mais pour les autres, je vais tenter de vous l'expliquer de manière simple.

• On commence par déclarer et instancier un objet de type SqlConnection, auquel nous ne passons comme paramètre que : Context Connection=True.
• Nous déclarons ensuite objet de type SqlCommand, puis nous associons notre connexion (nouvellement créée) à notre objet SqlCommand.
• Nous définissons ensuite la requête SQL à exécuter : celle-ci comprend, par mesure de sécurité, un paramètre.
• Nous utilisons alors la nouvelle méthode AddWithValue pour ajouter, directement à notre objet SqlCommand, le paramètre de notre requête, ainsi que sa valeur.
• Il ne nous reste plus qu'à ouvrir la connexion, exécuter la requête, récupérer le résultat (comme nous ne nous attendons à récupérer qu'une seule valeur, nous utilisons ExecuteScalar), puis nous fermons la connexion.
• Finalement, nous retournons le résultat de la requête SQL à l'utilisateur.

Il ne vous reste plus qu'à compiler votre fonction puis à la déployer sur votre serveur pour pouvoir la tester.

Là, vous voyez directement le résultat de l'exécution de votre fonction dans SQL Server, mais sachez que vous pouvez tester votre fonction depuis Visual Studio.

Pour cela, vous avez deux possibilités.

Tout d'abord, vous pouvez, dans Visual Studio, ouvrir le répertoire «  Test Scripts » de votre solution et éditer le fichier «  Tests.sql ». Ce fichier, qui contient un ensemble de commandes SQL que vous pouvez modifier (pour y insérer vos propres requêtes par exemple), pourra être exécuté directement depuis Visual Studio.

Pour cela, insérez le texte de la (ou les) requête(s) que vous souhaitez exécuter, puis faites un clic droit et choisissez «  Run To Cursor ».

Voyons cela en images :

Appuyer sur F5 pour déboguer l'application et visualiser le résultat dans l'onglet «  Output » de Visual Studio.

La deuxième possibilité pour exécuter votre fonction depuis Visual Studio est de passer par l'explorateur de serveur (Server Explorer).

Appuyez sur «  Ctrl + Alt + S » et développez l'arborescence jusqu'à voir la fonction que vous venez de créer. Faites un clic droit et choisissez «  Execute ». L'assistant qui apparaît vous demande de saisir une valeur pour le paramètre de la fonction.

Une fois que vous avez appuyé sur «  OK », visualisez, une fois encore, le résultat dans l'onglet «  Output » de Visual Studio.

Si vous souhaitez déployer votre assembly (fonction) .NET sur un autre serveur SQL, sachez que vous pouvez le faire très simplement, dès lors que vous possédez la DLL de votre fonction.

En effet, après avoir créé votre assembly, il vous faut juste la charger, dans votre serveur SQL, au moyen de la commande T-SQL CREATE ASSEMBLY :

CREATE ASSEMBLY SQLServer2005Project FROM 'C:\SQLServer2005Project.dll'

La commande CREATE ASSEMBLY prend en paramètre le chemin vers l'assembly que vous souhaitez charger dans SQL Server. Cela peut-être un chemin local, mais la plupart du temps, il s'agit d'un chemin vers un répertoire partagé du réseau. Lorsque cette commande est exécutée, l'assembly est copiée dans la base de données Master.

Vous avez également la possibilité de supprimer une assembly, en utilisant la commande DROP ASSEMBLY :

DROP ASSEMBLY SQLServer2005Project.dll

Vous devez utiliser cette commande lorsque vous effectuez des modifications sur votre assembly .NET, et que vous voulez qu'elles soient prises en compte dans SQL Server : vous devez supprimer l'assembly (DROP ASSEMBLY) puis la réimporter (CREATE ASSEMBLY).

Maintenant que cette phase est terminée, il ne vous reste plus qu'une chose à faire pour pouvoir utiliser votre fonction dans SQL Server. Pour le moment vous avez créé, déployé et enregistré l'assembly dans SQL Server : il ne vous reste plus qu'à associer la définition de la fonction SQL Server à la méthode appropriée dans l'assembly précédemment enregistrée.

Comme cela doit vous paraitre un peu vague, nous allons voir cela en exemple.
Nous allons utiliser la commande CREATE FUNCTION pour créer une fonction utilisateur .NET, dans SQL Server :

CREATE FUNCTION GetCommentFromId(Int id)
RETURNS String
AS EXTERNAL NAME SQLServer2005Project:UserDefinedFunctions::GetCommentFromId

La clause AS EXTERNAL NAME vous permet de lier le nom de la fonction SQL Server à la fonction .NET de votre assembly.

Le format de cette clause est : Nom_de_l'assembly:Nom_de_la_classe::Nom_de_la_methode.

Surprenante (mais indispensable), cette procédure peut paraitre assez compliquée au premier abord, surtout lorsque l'on sait que tout ceci est réalisé automatiquement par Visual Studio 2005, en utilisant le menu «  Build » ;)