In the program,
the varying-length C structure, ifx_varlena_t, stores a binary
value for a var binary host variable. This data structure allows
you to transfer binary data without knowing the exact structure of
the internal format for the opaque data type. It provides a data buffer
to hold the data for the associated var binary host variable.
Important: The ifx_varlena_t structure is an opaque structure
to programs.
That is, you do not access its internal structure directly. The internal
structure of ifx_varlena_t might change in future releases.
Therefore, to create portable code, always use the accessor
functions for this structure to obtain and store values in the ifx_varlena_t structure.
For a list of these access
functions, see The lvarchar pointer and var binary library functions.
This section uses a varying-length opaque data type called image to
demonstrate how the var
binary host variable accesses an opaque data type. The image data
type encapsulates an image such as a JPEG, GIF, or PPM file. If the
image is less than 2 kilobytes, the data structure for the data type
stores the image directly. However, if the image is greater than 2
kilobytes, the data structure stores a reference (an LO-pointer structure)
to a smart large object that contains the image data. The following
figure shows the internal data structure for the image data
type in the database. Figure 1. Internal data structures for the image opaque
data type
typedef struct
{
int img_len;
int img_thresh;
int img_flags;
union
{
ifx_lop_t img_lobhandle;
char img_data[4];
}
} image_t;
typedef struct
{
point_t center;
double radius;
} circle_t;
The following figure shows the CREATE TABLE statement
that creates a table called image_tab that has a column of
type image and an image identifier. Figure 2. Creating a column of the image
opaque data type
The following figure shows how to use a var binary host
variable to insert and select data in the image_col column
of the image_tab table (see Creating a column of the image
opaque data type). Figure 3. Accessing the internal format
of the image opaque data type with a var binary host variable
#include <image.h>;
EXEC SQL BEGIN DECLARE SECTION;
var binary 'image' vbin_image;
EXEC SQL END DECLARE SECTION;
struct image_t user_image, *image_ptr;
int imgsz;
/* Load data into members of internal data structure
load_image(&user_image);
imgsz = getsize(&user_image);
/* Allocate memory for var binary data buffer */
ifx_var_flag(&vbin_image, 0);
ifx_var_alloc(&vbin_image, imgsz);
/* Assign data to data buffer of var binary host
* variable */
ifx_var_setdata(&vbin_image, &user_image, imgsz);
/* Insert a new image_tab row with a var binary host
* variable */
EXEC SQL insert into image_tab values (1, :vbin_image);
/* Deallocate image data buffer */
ifx_var_dealloc(&vbin_image);
/* Select an image_tab row from into a var binary
* host variable */
ifx_var_flag(&vbin_image, 1);
EXEC SQL select image_col into :vbin_image
from image_tab
where image_id = 1;
image_ptr = (image_t *)ifx_var_getdata(&vbin_image);
unload_image(&user_image);
ifx_var_dealloc(&vbin_image);
