CREATE TABLE TEST_BLOB (
    ID     INTEGER NOT NULL,
    FILE_  BLOB SUB_TYPE 0 SEGMENT SIZE 80
);

ALTER TABLE TEST_BLOB ADD PRIMARY KEY (ID);

procedure TForm1.btBLOBToDBClick(Sender: TObject);
var
  fs: TFileStream;
begin
  FDConnection1.Connected := True;
  FDTransaction1.StartTransaction;

  FDQuery1.SQL.Text := 'insert into TEST_BLOB(ID, FILE_) values(1, :FILE_)';
  FDQuery1.ParamByName('FILE_').DataType := ftStream;
  FDQuery1.ParamByName('FILE_').ParamType := ptInput;
  FDQuery1.ParamByName('FILE_').StreamMode := smOpenRead;
  FDQuery1.ExecSQL;
  fs := TFileStream.Create('C:\Work\disk.iso', fmOpenRead);
  try
    FDQuery1.ParamByName('FILE_').AsStream.CopyFrom(fs, -1);
  finally
    fs.Free;
  end;
  FDQuery1.CloseStreams;

  FDTransaction1.Commit;
  FDConnection1.Connected := False;
end;

procedure TForm1.btBLOBToFileClick(Sender: TObject);
var
  s: TStream;
  fs: TFileStream;
begin
  FDConnection1.Connected := True;
  FDTransaction1.StartTransaction;

  FDQuery1.FetchOptions.AutoFetchAll := afDisable;
  FDQuery1.FetchOptions.Cache := [fiDetails, fiMeta];
  FDQuery1.FetchOptions.Items := [fiDetails, fiMeta];

  FDQuery1.SQL.Text := 'select ID, FILE_ from TEST_BLOB where ID = :ID';
  FDQuery1.MasterFields := 'ID';
  FDQuery1.ParamByName('ID').AsInteger := 1;
  FDQuery1.Open;
  if not FDQuery1.Eof then begin
    fs := TFileStream.Create('C:\Work\disk2.iso', fmCreate);
    try
      s := FDQuery1.CreateBlobStream(FDQuery1.FieldByName('FILE_'), bmRead);
      fs.CopyFrom(s, -1);
    finally
      fs.Free;
    end;
  end;
  FDQuery1.CloseStreams;
  FDQuery1.Close;

  FDTransaction1.Commit;
  FDConnection1.Connected := False;
end;

SET TERM ^ ;

create or alter procedure TEST_SPLIT (
    ID integer)
returns (
    OCTET_LENGTH_ bigint,
    BIT_LENGTH_ bigint,
    CHAR_LENGTH_ bigint)
as
begin
  select octet_length(FILE_), bit_length(FILE_), char_length(FILE_)
  from TEST_BLOB
  where ID = :ID
  into :OCTET_LENGTH_, :BIT_LENGTH_, :CHAR_LENGTH_;
  suspend;
end^

SET TERM ; ^

procedure TForm1.btBLOBToFileIBXClick(Sender: TObject);
var
  s: TStream;
  fs: TFileStream;
begin
  IBDatabase1.Open;
  IBQuery1.SQL.Text := 'select ID, FILE_ from TEST_BLOB where ID = :ID';
  IBQuery1.ParamByName('ID').AsInteger := 1;
  IBQuery1.Open;
  if not IBQuery1.Eof then begin
    fs := TFileStream.Create('C:\Work\disk.iso', fmCreate);
    try
      s := IBQuery1.CreateBlobStream(IBQuery1.FieldByName('FILE_'), bmRead);
      fs.CopyFrom(s, -1);
    finally
      fs.Free;
    end;
  end;
  IBQuery1.Close;
  IBDatabase1.Close;
end;

#include <stdlib.h>
#include <ibase.h>
#include <fstream>
#include <iostream>

#define DATABASE_PATH    "C:\\Work\\TEST_BLOB.FDB"
#define OUTPUT_FILE_PATH "C:\\Work\\disk2.iso"
#define SQL_SELECT       "select FILE_ from TEST_BLOB where ID = '1'"

int main()
{
  char database[] = DATABASE_PATH;

  isc_db_handle db = 0;
  isc_tr_handle trans;

  ISC_STATUS status_vector[20];

  short dpb_buf_len = 20;

  char dpb_buf[] = {
				isc_dpb_version1,
				isc_dpb_user_name,
				6,
				'S','Y','S','D','B','A',
				isc_dpb_password,
				9,
				'm','a','s','t','e','r','k','e','y'
			  };

  isc_attach_database(status_vector, strlen(database), database, &db, dpb_buf_len, dpb_buf);

  if (status_vector[0] == 1 && status_vector[1])
  {
	isc_print_status(status_vector);

	return 1;
  }

  char *select = SQL_SELECT;

  XSQLDA *out_sqlda;

  out_sqlda = (XSQLDA *)malloc(XSQLDA_LENGTH(1));

  out_sqlda->version = SQLDA_VERSION1;

  out_sqlda->sqln = 1;

  isc_stmt_handle stmt;

  stmt = NULL;

  isc_dsql_allocate_statement(status_vector, &db, &stmt);

  char isc_tpb[] = {
				isc_tpb_version3,
				isc_tpb_read,
				isc_tpb_wait,
				isc_tpb_read_committed,
				isc_tpb_no_rec_version
			 };

  isc_start_transaction(status_vector, &trans, 1, &db, sizeof(isc_tpb), isc_tpb);
  if (status_vector[0] == 1 && status_vector[1])
  {
	isc_print_status(status_vector);

	return 1;
  }

  isc_dsql_prepare(status_vector, &trans, &stmt, 0, select, SQLDA_VERSION1, out_sqlda);

  ISC_QUAD blob_id;

  short flag;

  out_sqlda->sqlvar[0].sqldata = (char *) &blob_id;

  out_sqlda->sqlvar[0].sqltype = SQL_BLOB + 1;

  out_sqlda->sqlvar[0].sqllen = sizeof(ISC_QUAD);

  out_sqlda->sqlvar[0].sqlind = &flag;

  isc_dsql_execute(status_vector, &trans, &stmt, 1, NULL);

  ISC_STATUS fetch_stat;

  long SQLCODE;

  while ((fetch_stat = isc_dsql_fetch(status_vector, &stmt, 1, out_sqlda)) == 0) {}

  if (fetch_stat != 100L)
  {
    SQLCODE = isc_sqlcode(status_vector);

    isc_print_sqlerror(SQLCODE, status_vector);

    return 1;
  }

  isc_blob_handle blob_handle;

  blob_handle = NULL;

  char blob_segment[80];

  unsigned short actual_seg_len;

  isc_open_blob2(status_vector, &db, &trans, &blob_handle, &blob_id, 0, NULL);

  ISC_STATUS blob_stat;

  blob_stat = isc_get_segment(status_vector,
                              &blob_handle,
                              &actual_seg_len,
                              sizeof(blob_segment),
                              blob_segment);

  ofstream stream;

  stream.open(OUTPUT_FILE_PATH, std::ios_base::binary);

  while (blob_stat == 0 || status_vector[1] == isc_segment)
  {
    stream.write(&blob_segment[0], actual_seg_len);

    blob_stat = isc_get_segment(status_vector,
                                &blob_handle,
                                &actual_seg_len,
                                sizeof(blob_segment),
                                blob_segment);
  };

  stream.close();

  isc_close_blob(status_vector, &blob_handle);

  isc_commit_transaction(status_vector, &trans);

  if (db)
    isc_detach_database(status_vector, &db);

  return 0;
}