Insérer une Image dans une BDD SQL Server

Version imprimable

23/03/2009, 23h37
bluerequin

Insérer une Image dans une BDD SQL Server

Bonjour à tous,

Je veux insérer une image dans la base SQL et le problème ce que je n'arrive pas l'insérer, toujours erreur.
Est ce que vous pouvez m'aider à résoudre ce problème surtout sur le code de récupération de cette image pour une ultérieure utilisation dans vb.net.

J'ai une petite idée mais condensé:

Est-il conseillé de:

1. Ma base de données contienne des liens vers tes images, utilise un champs text (ou varchar).
2.Au contre, Placer l'image directement, alors il faut la placer dans un champs de type blob (si ce dernier n'existe pas, il faut enregistrer le code binaire de l'image).

"exécuter une requête (aller chercher champ blob dans table X)
déclarer content type image
afficher resultat requete"

?????

Merci d'avance
24/03/2009, 08h43
elsuket

Bonjour,

Citation:

1. Ma base de données contienne des liens vers tes images, utilise un champs text (ou varchar).

Globalement cela n'est pas conseillé, parce que vous placez dans les pages de votre tables des données "larges" qui mettent très peu de temps à remplir les pages.
En conséquence, pour la même requête vous devrez lire plus de pages, et celles-ci pourront rester dans le cache très peu de temps puisque vous le remplirez vite.

Si toutefois vous souhaitez faire cela, vous pouvez utiliser le type VARBINARY(MAX) (dès SQL Server 2005) ou IMAGE.
La différence entre ces deux types de donnée, c'est que VARBINARY(MAX) stocke les données dans les pages de la table, alors que le type IMAGE fait stocker dans les pages de la table un pointeur de 16 octets (je crois) vers la page contenant les données image (en ce sens les données image sont séparées des données de la table, donc surcharge supplémentaire ;))

Enfin, si vous êtes sous SQL Server 2008, il me semble que le type FILESTREAM est tout à fait adapté.
Si vous êtes sous une version antérieure, je crois que le mieux est de stocker le chemin d'accès au fichier image dans la table, et de la faire lire à votre application cliente pour pouvoir l'afficher.

Encore une autre solution : si vous êtes sous SQL Server 2005, vous pouvez écrire une procédure stockée d'assembly à laquelle vous passez l'UNC du fichier image à lire, et qui va le stocker dans une table en appelant une procédure stockée T-SQL de la même BD.
Ensuite il vous suffit d'en écrire une autre pour spécifier un répertoire et appeler séquentiellement pour chaque fichier du répertoire la première procédure stockée d'assembly ;)

@++ ;)

Il y'a deux école qui s'affonte :
1-La première soutient qu'il n'est pas bon d'insérer une image dans une base de données.
2-La 2ième soutient qu'il est plus facile de gerer des images dans une base de données.
Pour ma part, j'ai déjà eu à réaliser un projet pour le quel les images se trouvait dans une bd et jusqu'ici, les performances ne sont pas dégradés.

Voici comment par script sql, insérer une image dans une bd et comment extraire celle-ci.

-- Import image
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 Insert into dbo.t_Image(ImageName) values ('photo1.JPG') go update dbo.Image set Photo = (SELECT * FROM OPENROWSET(BULK 'e:\image\photo\photo1.JPG', SINGLE_BLOB)AS x ) WHERE ImageName='photo1.JPG' go -- Export image declare @SQLcommand nvarchar(4000) set @SQLcommand = 'bcp "SELECT Photo FROM mabase..t_ImageWarehouse" queryout "e:\image\photo\expphoto1.jpg" -T -n -SMonInstance' exec xp_cmdshell @SQLcommand go

24/03/2009, 10h05
bluerequin

Bonjour à Tous,

Merci à "elsuket" et "WOLO Laurent", mais en fait je dispose de plusieurs images, pour une ultérieure utilisation sur VB.Net, en fait je prévois à intégrer ces images pour les fiches des utilisateurs (Avatar), en plus ces images en des extensions différentes: Jpg et autres ...

J'ai déjà ajouter des images dans un dossier liées a ma table [Image], le question qui se pose c'est comment faire une manipulation d'Import de plusieurs images?

- En effet, je ne peux pas l'utiliser le Type FILESTREAM, vu que j'ai déjà débuter le projet avec SQL Server 2005.

Cordinalement.
24/03/2009, 10h15
elsuket

Le mieux me semble d'écrire une procédure stockée d'assembly (en C# ou en VB.NET) à laquelle vous passez le chemin du répertoire contenant les images à importer.
Dans la procédure, vous listez tous les fichiers qui sont contenus dans le répertoire et vous les insérez dans votre table en appelant une procédure T-SQL comme celle que vous a montré Laurent WOLO.

@++ ;)
24/03/2009, 11h02
SQLpro

Si vous êtes en SQL Server 2008, le mieux est alors d'utiliser le type FILESTREAM pour ce faire. Ce type est p^roche de ce que la norme SQL appelle le DATALINK

Lisez l'article que j'ai écrit à ce sujet : http://sqlpro.developpez.com/cours/stockerimages/

A +
24/03/2009, 11h24
WOLO Laurent

Commence par choisir la strategie : Image dans une base de données ou dans un filesystem ?
Et nous allons voir par la suite.
24/03/2009, 12h25
bluerequin

Bonjour à Tous,

Merci à "elsuket", "WOLO Laurent" et "SQLpro", la stratégie adopté est la suivante:

[FONT=&quot]Sur SQL Server 2005, le mieux est de stocker le chemin d'accès au fichier image dans la table, et de la faire lire à votre application cliente pour pouvoir l'afficher. Il est plus facile de gérer des images dans une base de données.[/FONT]
[FONT=&quot]Mais en fait, je réfléchie au [/FONT][FONT=&quot]conséquence a prévoie si le temps d'exécution de requête n'est pas bcp, si je peu dire "réduire le temps d'execution", évoqué par Mr [/FONT]elsuket.

D'autres part, est-il possible de manipuler plusieurs types de fichiers Images, JPG, GIF, PNG, JPEG, TIFF, etc ...

A mon avis, a utilisation ultérieure sur VB.Net, si c'est le cas d'évoquer celà dans le forum de BDD, j'utilise simplement Image.Save vers un MemoryStream, pour une transformation d'image en stream?

Voici deux procédures stockées d'assembly en C# pour faire cela :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
using System;
using System.Data;
using System.Data.SqlClient;
using System.Data.SqlTypes;
using System.IO;
using Microsoft.SqlServer.Server;
 
 
public partial class StoredProcedures
{
    [Microsoft.SqlServer.Server.SqlProcedure]
    // Insère un fichier image en base
    public static void stockeUneImage(string pathImage)
    {
        try
        {
            // Vérification que le fichier existe
            if (!File.Exists(pathImage))
            {
                throw new Exception("Le fichier " + pathImage + " n'existe pas !");
            }
            else
            {
                // Récupération des infos du fichier
                FileInfo fichierImage = new FileInfo(pathImage);
 
                // Ouverture en lecture du fichier
                Stream ficherImageStream = fichierImage.OpenRead();
 
                // Stockage du fichier dans un flux d'octets
                Byte[] oFichierImage = new Byte[ficherImageStream.Length];
                ficherImageStream.Read(oFichierImage, 0, (int)fichierImage.Length);
 
                // Fermeture du fichier
                ficherImageStream.Close();
 
                // Insertion du fichier en base
                using(SqlConnection sqlcnx = new SqlConnection("context connection=true"))
                {
                    sqlcnx.Open();
 
                    // Création de l'appel de procédure stockée
                    SqlCommand requete = new SqlCommand("PsInsertImage", sqlcnx);
                    requete.CommandType= CommandType.StoredProcedure;
                    requete.Parameters.Add("@nomImage", SqlDbType.NVarChar, 255).Value = fichierImage.Name;
                    requete.Parameters.Add("@image", SqlDbType.Image).Value = oFichierImage;
 
                    // Exécution de la procédure stockée
                    SqlContext.Pipe.ExecuteAndSend(requete);
                }
            }
        }
        catch(Exception e)
        {
            SqlPipe pipe = SqlContext.Pipe;
            pipe.Send("Des erreurs se sont produites durant l'exécution de stockeUneImage :");
            pipe.Send(e.Message);
            pipe.Send(e.StackTrace);
        }
    }
 
    // Insère tous les fichiers d'un répertoire en base
    public static void stockeUnDossierDImages(string pathFolder)
    {
        try
        {
            if (!Directory.Exists(pathFolder))
            {
                throw new Exception("Le dossier " + pathFolder + " n'existe pas !");
            }
            else
            {
                // Récupération des infos du dossier
                DirectoryInfo dossier = new DirectoryInfo(pathFolder);
 
                // Tableau qui va contenir des infos sur tous les fichiers contenus dans ce dossier
                FileInfo[] fichiersDuDossier = dossier.GetFiles();
 
                // Insertion de chaque fichier en base
                foreach (FileInfo fichier in fichiersDuDossier)
                {
                    stockeUneImage(fichier.FullName);
                }
            }
        }
        catch(Exception e)
        {
            SqlPipe pipe = SqlContext.Pipe;
            pipe.Send("Des erreurs se sont produites durant l'exécution de stockeUnDossierDImages :");
            pipe.Send(e.Message);
            pipe.Send(e.StackTrace);
        }
    }
};

Voici la table :

Code:

1
2
3
4
5
6
7
CREATE TABLE Images
(
	IDImage INT NOT NULL IDENTITY CONSTRAINT PK_Images PRIMARY KEY,
	nomImage NVARCHAR(255) NOT NULL,
	image VARBINARY(MAX) NOT NULL
)
GO

Et la procédure T-SQL:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
ALTER PROCEDURE PsInsertImage
	@nomImage NVARCHAR(255),
	@image VARBINARY(MAX)
AS
BEGIN
	SET NOCOUNT ON
 
	IF EXISTS
	(
		SELECT *
		FROM dbo.Images
		WHERE nomImage = @nomImage
	)
	BEGIN
		RETURN
	END
	ELSE
	BEGIN
		INSERT INTO dbo.Images
		(
			nomImage,
			image
		)
		VALUES
		(
			@nomImage,
			@image
		)
	END
END
GO

Citation:

D'autres part, est-il possible de manipuler plusieurs types de fichiers Images, JPG, GIF, PNG, JPEG, TIFF, etc ...

Vous pouvez manipuler tous types de fichiers, il faut faire attention à ce que vos dossiers ne contiennent que des images, sinon passer un masque d'extension de fichier à la méthode GetFiles dans stockeUnDossierDImages.

Pour réduire le temps d'extraction, cela dépend de votre requête.
Si nous partons de la table que je fournis plus haut, j'aurais ajouté, en plus de l'index de clé primaire implicitement créé par la contrainte :

Code:

1
2
3
CREATE INDEX IX_Images_nomImage_ICL_Image
ON Images(nomImage)
INCLUDE (Image)

@++ ;)

Bon début de code esulket. mais ....

1-Pas besion de faire une sp .net
je préfère une autre variante :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
CREATE PROCEDURE [dbo].[extimage_sign_insert]
	@IMG_MBR_ID int,
	@img_ch_name varchar(20),
	@img_photo image
AS
BEGIN
	SET NOCOUNT ON
	INSERT INTO dbo.IMAGE_SIGN(
					IMG_MBR_ID,  
					IMG_PHOTO,
					img_ch_name
				   )
	VALUES(
		@IMG_MBR_ID, 
		@img_photo,
		@img_ch_name
		) ;
 
	SET NOCOUNT OFF
END
GO

2- Un code C# pour le jouer :
une classe de logique d'accès au donnée

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
class TUpdateImage
    {
        ///
        ///This class enable the application to communicate with 
        ///The database, This class deal only with table that has 4 fields
        ///Particulary a generic table t_user
        ///
        private string m_cmdSelect = "";
        private string m_cmdInsert = "";
        private string m_cmdUpdate = "";
 
 
        // This flag ensures that the user does not attempt
        // to restart the command or close the form while the 
        // asynchronous command is executing.
        //public bool isExecuting;
 
        private string m_ID = "";
        private string m_chemain = "";
        private byte[] m_chunk;
 
        //Hold the parameter name that is use in all sql server procedure
        private SqlParameter prmID;
        private SqlParameter prmChunk;
        private SqlParameter prmchemain;
        private SqlParameter prmPtrval;
 
 
        public TUpdateImage(string cmdSelect, string cmdInsert, string cmdUpdate, string cmdDelete)
        {
            this.prmID = new SqlParameter("@img_mbr_id", SqlDbType.Int);
            this.prmchemain = new SqlParameter("@img_ch_name", SqlDbType.VarChar, 20);
            this.prmChunk = new SqlParameter("@img_photo", SqlDbType.Binary, Principal.BUFFER_LENGTH);
            this.prmPtrval = new SqlParameter("@Ptrval", SqlDbType.Binary, 16);
            this.prmPtrval.Direction = ParameterDirection.Output;
            this.cmdSelect = cmdSelect;
            this.cmdUpdate = cmdUpdate;
 
        }
 
        public string ID
        {
            set { m_ID = value; }
            get { return m_ID; }
        }
        public byte[] Chunk
        {
            set { m_chunk = value; }
            get { return m_chunk; }
        }
        public string cmdSelect
        {
            set { m_cmdSelect = value; }
            get { return m_cmdSelect; }
        }
        public string cmdUpdate
        {
            set { m_cmdUpdate = value; }
            get { return m_cmdUpdate; }
        }
 
        public string chemain
        {
            get
            {
                return m_chemain;
            }
            set
            {
                m_chemain = value;
            }
        }
 
        public DataSet GetData(string strAdresse2)
        {
            SqlConnection cn = new SqlConnection(Principal.GetConnectionString());
            SqlCommand cmd = new SqlCommand(cmdSelect, cn);
            cmd.CommandType = CommandType.StoredProcedure;
 
            DataSet ds = new DataSet("t_user");
            SqlDataAdapter sqlDta = new SqlDataAdapter(cmd);
 
            try
            {
                //prmAdresse2.Value = strAdresse2;
                //cmd.Parameters.Add(prmAdresse2);
                //Fill the dataset
                sqlDta.Fill(ds);
                return ds;
            }
            catch (SqlException ex)
            {
                Principal.ProcessError(ex);
                return null;
            }
            finally
            {
 
                if (cn != null) cn.Close();
                if (ds != null) ds.Dispose();
                if (cmd != null)
                {
                    cmd.Parameters.Clear();
                    cmd.Dispose();
                }
                if (sqlDta != null) sqlDta.Dispose();
            }
        }
        public DataSet GetData()
        {
            SqlConnection cn = new SqlConnection(Principal.GetConnectionString());
            SqlCommand cmd = new SqlCommand(cmdSelect, cn);
            cmd.CommandType = CommandType.StoredProcedure;
            DataSet ds = new DataSet("t_Image_sign");
            SqlDataAdapter sqlDta = new SqlDataAdapter(cmd);
 
            try
            {
                //Fill the dataset
                sqlDta.Fill(ds);
                return ds;
            }
            catch (SqlException ex)
            {
                Principal.ProcessError(ex);
                return null;
            }
            finally
            {
 
                if (cn != null) cn.Close();
                if (ds != null) ds.Dispose();
                if (cmd != null) cmd.Dispose();
                if (sqlDta != null) sqlDta.Dispose();
            }
        }
        public void Add()
        {
            SqlConnection cn = new SqlConnection(Principal.GetConnectionString());
            SqlCommand cmd = new SqlCommand(m_cmdInsert, cn);
            cmd.CommandType = CommandType.StoredProcedure;
            //Set SqlParameter value
            SetParameterValue();
            //Add parameters to the command
            AddParameters(cmd);
            //Set the parameters values
            try
            {
                cn.Open();
                cmd.CommandText = "dbo.extimage_sign_insert";
                cmd.ExecuteNonQuery();
            }
            catch (SqlException ex)
            {
                if (cn != null) cn.Close();
            }
            finally
            {
 
                if (cn != null)
                {
                    cn.Close();
                }
                if (cmd != null)
                {
                    cmd.Parameters.Clear();
                    cmd.Dispose();
                }
            }
        }
        public int AddImage()
        {
            SqlConnection cn = new SqlConnection(Principal.GetConnectionString());
            SqlCommand cmd = new SqlCommand(m_cmdInsert, cn);
            cmd.CommandType = CommandType.StoredProcedure;
            //Set SqlParameter value
            SetParameterValue();
            //Add parameters to the command
            AddParameters(cmd);
            //Set the parameters values
            int ret = 0;
            try
            {
                cn.Open();
                cmd.CommandText = "dbo.extimage_sign_insert";
                ret = cmd.ExecuteNonQuery();
                return ret;
            }
            catch (SqlException ex)
            {
                if (cn != null) cn.Close();
                return ret;
            }
            finally
            {
 
                if (cn != null)
                {
                    cn.Close();
                }
                if (cmd != null)
                {
                    cmd.Parameters.Clear();
                    cmd.Dispose();
                }
            }
        }
 
        public int DeleteImage()
        {
            SqlConnection cn = new SqlConnection(Principal.GetConnectionString());
            SqlCommand cmd = new SqlCommand(m_cmdInsert, cn);
            cmd.CommandType = CommandType.StoredProcedure;
            //Set SqlParameter value
            prmID.Value = this.ID;
            //Add parameters to the command
            cmd.Parameters.Add(prmID);
            //Set the parameters values
            int ret = 0;
            try
            {
                cn.Open();
                cmd.CommandText = "dbo.proc_image_sign_delete";
                ret = cmd.ExecuteNonQuery();
                return ret;
            }
            catch (SqlException ex)
            {
                if (cn != null) cn.Close();
                return ret;
            }
            finally
            {
 
                if (cn != null)
                {
                    cn.Close();
                }
                if (cmd != null)
                {
                    cmd.Parameters.Clear();
                    cmd.Dispose();
                }
            }
        }
        public int Update()
        {
            SqlConnection cn = new SqlConnection(Principal.GetConnectionString());
            SqlCommand cmd = new SqlCommand(cmdUpdate, cn);
            cmd.CommandType = CommandType.StoredProcedure;
            //Set SqlParameter value
            SetParameterValue();
            //Add parameters to the command
            AddParameters(cmd);
            //Set the parameters values
            try
            {
                cn.Open();
                return cmd.ExecuteNonQuery();
            }
            catch (SqlException ex)
            {
                Principal.ProcessError(ex);
                return -2;
            }
            finally
            {
 
                if (cn != null)
                {
                    cn.Close();
                }
                if (cmd != null)
                {
                    cmd.Parameters.Clear();
                    cmd.Dispose();
                }
            }
        }
        private void SetParameterValue()
        {
            //Set SqlParameter value
            prmID.Value = m_ID;
            prmChunk.Value = m_chunk;
            prmchemain.Value = m_chemain;
 
        }
 
        private void AddParameters(SqlCommand cmd)
        {
            cmd.Parameters.Add(prmID);
            cmd.Parameters.Add(prmChunk);
            cmd.Parameters.Add(prmchemain); 
        }
 
        ~TUpdateImage()
        {
            prmID = null;
            prmChunk = null;
            prmchemain = null;
        }
    }

et enfin pour ajouter une image :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
//Récupérer les octets de l''image
FileInfo fichierImage = new FileInfo(pathImage);
Stream ficherImageStream = fichierImage.OpenRead();
Byte[] oFichierImage = new Byte[ficherImageStream.Length];
ficherImageStream.Read(oFichierImage, 0, (int)fichierImage.Length);
ficherImageStream.Close();
//Inserer dans la base de données.
TUpdateImage updateimg = new TUpdateImage("", "dbo.extimage_sign_insert", "", "");
updateimg.ID = txtNumMembre.Text;
updateimg.chemain = pathImage;
updateimg.Chunk = oFichierImage;
int rowcount = updateimg.AddImage();

Et là c'est presque parfait !

24/03/2009, 19h04
elsuket

Bien vu, après comme tu as dit c'est une histoire de goûts :D
Pour ma part je préfère les procédures stockées d'assembly ;)

@++ ;)

Je suis d'accord pour le principe des deux écoles mais pas pour l'écriture des procedures stockées CLR ou SQL
Il faut noter que le CLR est recommandé pour les calculs, les itérations bref la logique procedurale et le SQL pour la logique ensembliste et partant de cela, je ne suis pas d'avis que vous puissiez insérer les images via une sp clr.

ici, pas besoin de tester l'index ci-bas suffira.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ALTER PROCEDURE PsInsertImage @nomImage NVARCHAR(255), @image VARBINARY(MAX) AS INSERT INTO dbo.Images ( nomImage, image ) VALUES ( @nomImage, @image )GO
Vous pouvez manipuler tous types de fichiers, il faut faire attention à ce que vos dossiers ne contiennent que des images, sinon passer un masque d'extension de fichier à la méthode GetFiles dans stockeUnDossierDImages.

Pour réduire le temps d'extraction, cela dépend de votre requête.
Si nous partons de la table que je fournis plus haut, j'aurais ajouté, en plus de l'index de clé primaire implicitement créé par la contrainte :
Code:

1 2 3 CREATE INDEX IX_Images_nomImage_ICL_Image ON Images(nomImage) INCLUDE (Image)
@++ ;)[/QUOTE]

24/03/2009, 21h00
elsuket

Citation:

Il faut noter que le CLR est recommandé pour les calculs, les itérations bref la logique procedurale et le SQL pour la logique ensembliste

Je suis entièrement d'accord avec vous, mais la gestion des images ou de tout autre type de contenu BLOB ne fait partie ni de l'un ni de l'autre.

Le choix est rendu difficile parce qu'on tente de faire gérer aux SGBDR des données qui ne sont pas de nature relationnelle, de faire fusionner deux logiques qui sont totalement différentes.

C'est pour cela que pour moi la meilleure solution reste de stocker le chemin du fichier dans une des colonnes de la table ;)

@++ ;)
24/03/2009, 23h06
bluerequin

Bonsoir à Tous,

Je tiens Mr, vous remercier pour toutes les informations, j'ai opté pour la solution : récupérer les images, à afficher, qui sont stocker dans un répertoire, mais avec une autre meilleur solution celle de donner a chaque image le nom de son ID, c.à.d : que pour chaque client qui a un ID sa photo prend comme nom ce ID.

Par Exemple : IDClient: 0001
Nom Image : 0001.Jpg

Cela bien évidement, permet une meilleur utilisation ultérieur pour la récupération de ces images sur (VB.Net).

Pouviez vous commenter cette solution? Et Merci Énormément.
25/03/2009, 09h29
WOLO Laurent

Citation:

Envoyé par elsuket

Je suis entièrement d'accord avec vous, mais la gestion des images ou de tout autre type de contenu BLOB ne fait partie ni de l'un ni de l'autre.

Profil les deux procedures et dit moi laquelle sera plus performante.
Il y a ce qu'on appelle "Pattern & Practices" et là dedans, il est vivement conseillé de penser performance au moment du design et c'est ce que je fais.

Citation:

Envoyé par elsuket

C'est pour cela que pour moi la meilleure solution reste de stocker le chemin du fichier dans une des colonnes de la table ;)

Et prier qu'il y ait active directory pour les droits et s'assurer que les dossiers partagés sont accessibles aux utilisateurs.

Citation:

Envoyé par bluerequin

Bonjour à tous,

Je veux insérer une image dans la base SQL et le problème ce que je n'arrive pas l'insérer, toujours erreur.
Est ce que vous pouvez m'aider à résoudre ce problème surtout sur le code de récupération de cette image pour une ultérieure utilisation dans vb.net.

J'ai une petite idée mais condensé:

Est-il conseillé de:

1. Ma base de données contienne des liens vers tes images, utilise un champs text (ou varchar).
2.Au contre, Placer l'image directement, alors il faut la placer dans un champs de type blob (si ce dernier n'existe pas, il faut enregistrer le code binaire de l'image).

"exécuter une requête (aller chercher champ blob dans table X)
déclarer content type image
afficher resultat requete"

?????

Merci d'avance
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 public void ajouter() { connection.con.Open(); SqlCommand cmd1 = new SqlCommand("insert into gest_user (photo_user) values ( "@photo", connection.con); MemoryStream stream = new MemoryStream(); pictureBox1.Image.Save(stream, System.Drawing.Imaging.ImageFormat.Jpeg); byte[] pic = stream.ToArray(); cmd1.Parameters.AddWithValue("@photo", pic); cmd1.ExecuteNonQuery(); connection.con.Close(); }