From Borland
Streaming Bitmaps and other Binary Data to BLOB Fields - by Borland Developer
Support Staff
Abstract:basics on using TBLOBStream to read/write records in a database
If you are reading this article you have probably discovered that reading and
writing to and from BLOB fields is not as straight forward as their
counterparts, integer and character. The wonderful implicit assignments to
integer and character fields just don't exist. Don't despair. Accessing data
in a BLOB is not as simple as other field types, but is by no means difficult.
TBLOBStream
The main difference in accessing BLOB data is the use of streams for the actual
data transfer. Once you have a reference to your Dataset's BLOB field, you
open a stream to it by passing that reference to TBLOBStream's Create method.
TBLOBStream descends from TStream and encapsulates the operations that allow
your applications to read from or write to Binary Large Object(BLOB) fields.
There are a few things that you should take into consideration when creating
your BLOB streams(s). One is that you should make sure to create a new instance
of TBLOBStream for every field you plan to read from and free it when you are
done. That other is that even though TBLOBStream lets you create instances of
it to use with any kind of DataSet, it is best to instead call the particular
DataSet's CreateBLOBStream method. It works exactly like TBLOBStream.Create,
but it instantiates an object specific for that Dataset(TTable,TQuery).
My examples will uses this method.
A Simple Example: Streaming Bitmaps
While BLOBs can hold many different kinds of data, including MEMOs and... well
just about anything you want, my example will focus on the streaming of bitmap
files. These concepts hold true for all types of data.
Using the BDE
First, start a new Delphi application and drop on your database components for
your connection. This will include a TDataBase and TQuery. Hook your Query to
your Database object and set it's RequestLive property to true, since we will
be inserting data. Now we will write your bitmap image to you database field.
First we will want a Bitmap to work with. After declaring a TBitmap, create it
and load a file with your favorite picture into it.
MyFavoriteBitmap := TBitmap.Create;
MyFavoriteBitmap.LoadFromFile('drive
athMyFavoriteBitmap.bmp');
Once you have a Bitmap ready and waiting, you can go ahead and create your BLOB
stream. To do this, you will need to get a reference to your blobfield from the
query. If you know the name for the field, TDataSet.FindByName is the easiest.
Now Pass this reference into CreateBLOBStream along with the
BlobStreamMode(bmRead,bmWrite,bmReadWrite), which will return reference to a
TStream. We are going to use this to actually stream the file using TBitmap's
SaveToStream method.
procedure SavePictureToDatabase;
var
BlobField: TField;
BS: TStream;
begin
with Query1 do
begin
Insert;
BlobField := FieldByName('picturefield');
BS := CreateBlobStream(BlobField,bmWrite);
Bitmap.SavetoStream(BS);
Post;
end;
end;
Using dbExpress Those of you using the new dbExpress components will find the
process is identical with a few minor exceptions. If you are using TSQLQuery
or TSQLTable, you are enjoying their extremely fast execution for your
reporting applications. But since they do not cache their data, their is no
way for you to edit any records, let alone your BLOBS. Don't forget that you
must use TSQLClientDataSet instead of TSQLDataSet's to achieve this
functionality. In code, the difference is trivial for writing yourt picture
to a database.
procedure SavePictureToDatabase;
var
BlobField: TField;
BS: TStream;
begin
with SQLClientDataSet1 do
begin
Insert;
BlobField := FieldByName('picturefield');
BS := CreateBlobStream(BlobField,bmWrite);
Bitmap.SavetoStream(BS);
Post;
end;
end;
When you are ready to read you bitmap back out, use the built in TBitmap method
and you are set.
Blobfield := FieldbyName('picturefield');
BS := CreateBlobStream(BlobField,bmReadWrite);
MyFavoriteBitmap.LoadFromStream(BS);
Other types of binary data
When moving in large chunks of data that do not have convenient loading and
saving methods like TBitmap, you must employ the TStream methods
(Read, ReadBuffer, Write, WriteBuffer) manually. You can even stream
components and their properties using WriteComponent and ReadComponent,
were you so inclined.
var
MyComponent: TMyComponent //any TComponent
begin
MyComponent := TMyComponent.Create;
MyComponent.aProperty := aValue;
BS := CreateBlobStream(Blobfield,bmReadWrite);
BS.WriteComponent(MyComponent);
end;
There you have it. A quick intro to using BLOBs to store binary data.
I think the moral of the story is quite clear: Don't take candy from
strangers', kids.
tx_temp2)') ;
]