Blog de Nico-pyright(c) » Sql Serveur

[C#] [Sql Serveur 2008] Le type HierarchyID et les datasets typés, suite

nico-pyright(c) — Tue, 22 Sep 2009 20:47:58 +0000

Suite à ce billet [.NET][SGBD][SQL Server] [Sql Serveur 2008] Le type HierarchyID et les datasets typés, j’ai crée une petite fonction, incomplète pour l’instant, qui permet d’appeler une procédure stockée avec les bons paramètres, dont les paramètres de type HierarchyID.

L’”astuce” consiste en l’utilisation du tableau typeAndSqlTypeAndUdt qui permet de faire la relation entre un type .Net et son type SQL Server (agrémenté de l’UDT si besoin).

Voici le code de démo :

class Program
{
static void Main()
{

List<SqlParamObject> paramObjects = new List<SqlParamObject>
{

                new SqlParamObject { ParameterName = "@Guid", Type = typeof (Guid), Value = monGuid },
                new SqlParamObject { ParameterName = "@MonEntier", Type = typeof (int), Value = monEntier },
                new SqlParamObject { ParameterName = "@HierarchyID", Type = typeof (SqlHierarchyId), Value = hierarchyID },
            };

ExecuteNonQuery(ConfigurationManager.ConnectionStrings["MA_CONNEXION"], "maProcedureStockee", paramObjects);
}

public static void ExecuteNonQuery(ConnectionStringSettings connectionStringSettings, string storedProcedureName, List<SqlParamObject> sqlParamObjects)
{

        DbProviderFactory factory = DbProviderFactories.GetFactory(connectionStringSettings.ProviderName);
        using (IDbConnection connection = factory.CreateConnection())
        {

connection.ConnectionString = connectionStringSettings.ConnectionString;

connection.Open();

using (IDbCommand command = factory.CreateCommand())
{

command.Connection = connection;

foreach (SqlParamObject paramObject in sqlParamObjects)
{

                    string paramName = paramObject.ParameterName.StartsWith("@") ? paramObject.ParameterName : string.Format("@{0}", paramObject.ParameterName);
                    var typeAndUdtTypeName = GetTypeAndUdtTypeNameFromType(paramObject.Type);
                    object value = paramObject.Value ?? DBNull.Value;
                    SqlParameter sqlParameter = new SqlParameter(paramName, typeAndUdtTypeName.Key) { UdtTypeName = typeAndUdtTypeName.Value, Value = value };
                    command.Parameters.Add(sqlParameter);

}

command.CommandType = CommandType.StoredProcedure;
command.CommandText = storedProcedureName;

command.ExecuteNonQuery();

}

private static KeyValuePair<SqlDbType, string> GetTypeAndUdtTypeNameFromType(Type type)
{

Dictionary<Type, KeyValuePair<SqlDbType, string>> typeAndSqlTypeAndUdt = new Dictionary<Type, KeyValuePair<SqlDbType, string>>
{

                 { typeof(bool), new KeyValuePair<SqlDbType, string>(SqlDbType.Bit, "") },
                 { typeof(byte), new KeyValuePair<SqlDbType, string>(SqlDbType.TinyInt, "") },
                 { typeof(byte[]), new KeyValuePair<SqlDbType, string>(SqlDbType.Image, "") },
                 { typeof(DateTime), new KeyValuePair<SqlDbType, string>(SqlDbType.DateTime, "") },
                 { typeof(decimal), new KeyValuePair<SqlDbType, string>(SqlDbType.Decimal, "") },
                 { typeof(double), new KeyValuePair<SqlDbType, string>(SqlDbType.Float, "") },
                 { typeof(Guid), new KeyValuePair<SqlDbType, string>(SqlDbType.UniqueIdentifier, "") },
                 { typeof(Int16), new KeyValuePair<SqlDbType, string>(SqlDbType.SmallInt, "") },
                 { typeof(Int32), new KeyValuePair<SqlDbType, string>(SqlDbType.Int, "") },
                 { typeof(Int64), new KeyValuePair<SqlDbType, string>(SqlDbType.BigInt, "") },
                 { typeof(object), new KeyValuePair<SqlDbType, string>(SqlDbType.Variant, "") },
                 { typeof(string), new KeyValuePair<SqlDbType, string>(SqlDbType.VarChar, "") },
                 { typeof(int?), new KeyValuePair<SqlDbType, string>(SqlDbType.Int, "") },
                 { typeof(SqlHierarchyId), new KeyValuePair<SqlDbType, string>(SqlDbType.Udt, "HierarchyId") }
             };

        if (typeAndSqlTypeAndUdt.ContainsKey(type))
            return typeAndSqlTypeAndUdt[type];
        throw new NotImplementedException(string.Format("Type {0} is not yet supported", type));
    }

}

public class SqlParamObject
{
    public string ParameterName { get; set; }
    public object Value { get; set; }
    public Type Type { get; set; }
}

Notez que je ne peux pas faire un GetType de l’objet pour avoir son type, si celui-ci est nul, d’où l’utilisation d’une propriété Type.

[Sql Serveur 2008] Le type HierarchyID et les datasets typés

nico-pyright(c) — Wed, 11 Mar 2009 19:10:00 +0000

J’ai essayé d’exécuter une procédure stockée qui avait en paramètre un type HierarchyID.
Un truc du genre :

ALTER PROCEDURE [Ma_proc_stoc]
(
        @guid uniqueidentifier,
        @type int,
        @parent HIERARCHYID
)
AS

Et je me suis retrouvé avec cette erreur :

La propriété UdtTypeName doit être définie pour les paramètres UDT

J’ai essayé de voir où on pouvait mettre ce fameux paramètre dans mon dataset, mais j’ai été incapable de le trouver.

Si vous avez le même problème que moi, vous pouvez vous en sortir avec le classique objet IDbCommand. Il faudra utiliser le type SqlDbType.Udt et mettre le paramètre UdtTypeName à HierarchyId.

DbProviderFactory factory = DbProviderFactories.GetFactory(ProviderName);
using (IDbConnection connection = factory.CreateConnection())
{
    connection.ConnectionString = ConnectionString;
    connection.Open();
    using (IDbCommand command = factory.CreateCommand())
    {
        command.Connection = connection;

        SqlParameter guidParameter = new SqlParameter(« @guid », SqlDbType.UniqueIdentifier) { Value = Guid.NewGuid()};
        SqlParameter typeParameter = new SqlParameter(« @type », SqlDbType.Int) { Value = type };
        SqlParameter parentParameter = new SqlParameter(« @parent », SqlDbType.Udt) { UdtTypeName = « HierarchyId », Value = level};
        command.Parameters.Add(guidParameter);
        command.Parameters.Add(typeParameter );
        command.Parameters.Add(parentParameter );

        command.CommandType = CommandType.StoredProcedure;
        command.CommandText = « Ma_proc_stoc »;
        command.ExecuteNonQuery();
    }
}

Si vous connaissez un moyen pour paramétrer le dataset typés, je suis à l’écoute

Le type HierarchyID de sql serveur 2008

nico-pyright(c) — Thu, 05 Mar 2009 19:00:00 +0000

Nonon, ca ne sera pas un cours sur le type HierarchyID, je ne suis aucunement DBA

Mais comme tout développeur, j’ai besoin de modéliser des tables de base de données et d’écrire du SQL.

J’ai pu lire 2-3 petites choses sur le net sur les HierarchyID mais toujours le même exemple, celui de la hiérarchie entre les employés d’une boite.

Je vous livre ici le fruit de mes recherches.

Je me propose ici de modéliser un disque dur, c’est à dire un volume, composé de dossiers ou de fichiers, qui peuvent eux même contenir des sous-dossiers ou des fichiers.

On aura donc trois tables :

Qu’on va créer ainsi

CREATE TABLE Repertoire
(IDRepertoire INT PRIMARY KEY NOT NULL IDENTITY,
Nom VARCHAR(255) NOT NULL,
NiveauRepertoire HIERARCHYID)

CREATE TABLE Disque
(IDDisque INT PRIMARY KEY NOT NULL IDENTITY,
Nom VARCHAR(255) NOT NULL,
IDRepertoire int NOT NULL,
constraint FK_REP_DISK foreign key (IDRepertoire) references Repertoire (IDRepertoire) )

CREATE TABLE Fichier
(IDFichier INT PRIMARY KEY NOT NULL IDENTITY,
Nom VARCHAR(255) NOT NULL,
IDRepertoire int NOT NULL,
constraint FK_REP_FICHIER foreign key (IDRepertoire) references Repertoire (IDRepertoire) )

INSERT INTO Repertoire (Nom, NiveauRepertoire)
VALUES (‘root’, HIERARCHYID::GetRoot())

Notez qu’on insère au moment de la création des tables, un noeud de niveau root.

Ajouter un disque consistera à créer un répertoire à la racine du root et d’insérer une valeur dans la table disque, d’où la procédure stockée suivante :

CREATE PROCEDURE AjoutDisque
(
        @nomDisque varchar(255)
)
AS
BEGIN

        declare @niveau hierarchyid
        set @niveau = HIERARCHYID::GetRoot()
        exec AjoutRepertoire @niveau, @nomDisque
        insert into Disque (Nom, IDRepertoire)
                values (@nomDisque, @@IDENTITY)
END

Pour créer un répertoire, on ajoutera un noeud sous le noeud parent, et après un éventuel frère :

CREATE PROCEDURE AjoutRepertoire
(
        @parent Hierarchyid,
        @nomRepertoire varchar(255)
)
AS
BEGIN

        declare @frere HIERARCHYID
        SELECT @frere = Max(NiveauRepertoire)
                FROM Repertoire
                WHERE NiveauRepertoire.GetAncestor(1) = @parent;

INSERT INTO Repertoire (Nom, NiveauRepertoire)
VALUES (@nomRepertoire, @parent.GetDescendant(@frere, NULL))

END

Enfin, pour créer un fichier, on fera la relation avec son répertoire conteneur :

CREATE PROCEDURE AjoutFichier
(
        @IDRepertoire int,
        @nomFichier varchar(255)
)
AS
BEGIN

INSERT INTO Fichier (Nom, IDRepertoire)
VALUES (@nomFichier, @IDRepertoire)

END

Maintenant, je vais pouvoir créer la structure suivante :

c:\test\fichier1.txt
c:\test\fichier2.txt
c:\windows\system32\dll1.dll
c:\windows\system32\dll2.dll
c:\windows\Microsoft.Net\fichier.exe
d:\abc\def.txt

– creation de disque
exec AjoutDisque ‘c:\’

declare @idDisque int = @@IDENTITY

– creation du repertoire c:\test\
declare @niveau hierarchyid
select @niveau = Repertoire.NiveauRepertoire from Repertoire where Repertoire.IDRepertoire = (select Disque.IDRepertoire from Disque where IDDisque = @idDisque)
exec [AjoutRepertoire] @niveau, ‘test\’

– creation du fichier c:\test\fichier1.txt
– creation du fichier c:\test\fichier2.txt
declare @reperoireID int = @@IDENTITY
exec [AjoutFichier] @reperoireID, ‘fichier1.txt’
exec [AjoutFichier] @reperoireID, ‘fichier2.txt’

– creation du repertoire c:\windows\
select @niveau = Repertoire.NiveauRepertoire from Repertoire where Repertoire.IDRepertoire = (select Disque.IDRepertoire from Disque where IDDisque = @idDisque)
exec [AjoutRepertoire] @niveau, ‘windows\’

– creation du repertoire c:\windows\system32\
declare @reperoireID2 int
set @reperoireID2 = @@IDENTITY
select @niveau = Repertoire.NiveauRepertoire from Repertoire where Repertoire.IDRepertoire = @reperoireID2
        exec [AjoutRepertoire] @niveau, ‘system32\’
– creation du fichier c:\windows\system32\dll1.dll
– creation du fichier c:\windows\system32\dll2.dll
set @reperoireID = @@IDENTITY
        exec [AjoutFichier] @reperoireID, ‘dll1.dll’
        exec [AjoutFichier] @reperoireID, ‘dll2.dll’

– creation du repertoire c:\windows\Microsoft.NET\
        exec [AjoutRepertoire] @niveau, ‘Microsoft.NET\’
– creation du fichier c:\windows\Microsoft.NET\fichier.exe
set @reperoireID = @@IDENTITY
        exec [AjoutFichier] @reperoireID, ‘fichier.exe’

——————

– creation de disque
exec AjoutDisque ‘d:\’

set @idDisque = @@IDENTITY

– creation du repertoire d:\abc\
select @niveau = Repertoire.NiveauRepertoire from Repertoire where Repertoire.IDRepertoire = (select Disque.IDRepertoire from Disque where IDDisque = @idDisque)
exec [AjoutRepertoire] @niveau, ‘abc\’

– creation du fichier d:\abc\def.txt
set @reperoireID = @@IDENTITY
exec [AjoutFichier] @reperoireID, ‘def.txt’

Maintenant, on pourra simplement récupérer tous les sous noeuds d’un disque, avec :

select @niveau = NiveauRepertoire from Repertoire
        INNER JOIN Disque on Disque.IDRepertoire = Repertoire.IDRepertoire
        where Disque.Nom = ‘c:\’
select *, NiveauRepertoire.GetAncestor(1) as ancestor from Repertoire
        LEFT JOIN Fichier on Fichier.IDRepertoire = Repertoire.IDRepertoire
        Where NiveauRepertoire.IsDescendantOf(@niveau) = 1

select @niveau = NiveauRepertoire from Repertoire
        INNER JOIN Disque on Disque.IDRepertoire = Repertoire.IDRepertoire
        where Disque.Nom = ‘d:\’
select *, NiveauRepertoire.GetAncestor(1) as ancestor from Repertoire
        LEFT JOIN Fichier on Fichier.IDRepertoire = Repertoire.IDRepertoire
        Where NiveauRepertoire.IsDescendantOf(@niveau) = 1

ce qui nous donne comme résultat :

Voilà pour ma maigre contribution sur les hierarchyID.

Il y a peut-être une meilleure façon de faire, dans ce cas, n’hésitez pas à me donner votre solution