Sealing GdaBinary: API change

30 files changed, 561 insertions, 415 deletions

diff --git a/libgda-report/engine/rt-parser.c b/libgda-report/engine/rt-parser.c
index af619ea..4047957 100644
--- a/libgda-report/engine/rt-parser.c
+++ b/libgda-report/engine/rt-parser.c
@@ -427,7 +427,7 @@ rt_dump_tree_offset (RtNode *tree, gint offset)
 		g_free (copy);
 		g_print ("]\n");
 	}
-	else if (tree->binary.data) {
+	else if (gda_binary_get_data (tree->binary)) {
 		g_print ("BINARY\n");
 	}
 	else
@@ -472,7 +472,7 @@ rt_dump_tree_to_string (RtNode *tree, GString *string)
 		}
 		g_string_append (string, "]|");
 	}
-	else if (tree->binary.data)
+	else if (gda_binary_get_data (tree->binary))
 		g_string_append (string, "BINARY|");
 	else
 		g_string_append_c (string, '|');
@@ -500,8 +500,7 @@ rt_free_node (RtNode *node)
 	if (node->next)
 		rt_free_node (node->next);
 	g_free (node->text);
-	if (node->binary.data)
-		g_free (node->binary.data);
+	gda_binary_free (node->binary);
 	g_free (node);
 }
 
@@ -520,8 +519,8 @@ merge_text_node_child (RtNode *tree)
 	if (! child)
 		return FALSE;
 
-	if ((tree->markup == RT_MARKUP_NONE) && !tree->binary.data &&
-	    (child->markup == RT_MARKUP_NONE) &&  ! child->child && child->text && !child->binary.data) {
+	if ((tree->markup == RT_MARKUP_NONE) && !gda_binary_get_data (tree->binary) &&
+	    (child->markup == RT_MARKUP_NONE) &&  ! child->child && child->text && !gda_binary_get_data (child->binary)) {
 		if (tree->text) {
 			gchar *tmp;
 			tmp = tree->text;
@@ -551,8 +550,8 @@ merge_text_node_siblings (RtNode *tree)
 		if (! tree->next)
 			break;
 		RtNode *next = tree->next;
-		if ((tree->markup == RT_MARKUP_NONE) && !tree->binary.data &&
-		    (next->markup == RT_MARKUP_NONE) && !next->binary.data &&
+		if ((tree->markup == RT_MARKUP_NONE) && !gda_binary_get_data (tree->binary) &&
+		    (next->markup == RT_MARKUP_NONE) && !gda_binary_get_data (next->binary) &&
 		    ! next->child && next->text) {
 			if (tree->text) {
 				gchar *tmp;
@@ -581,17 +580,15 @@ merge_text_node_siblings (RtNode *tree)
 static gboolean
 merge_single_child_text (RtNode *tree)
 {
-	if (! (tree->text || tree->binary.data) &&
+	if (! (tree->text || gda_binary_get_data (tree->binary)) &&
 	    tree->child && !tree->child->next &&
 	    ! tree->child->child &&
-	    (tree->child->text || tree->child->binary.data) &&
+	    (tree->child->text || gda_binary_get_data (tree->child->binary)) &&
 	    (tree->child->markup == RT_MARKUP_NONE)) {
 		tree->text = tree->child->text;
 		tree->child->text = NULL;
-		tree->binary.data = tree->child->binary.data;
-		tree->child->binary.data = NULL;
-		tree->binary.binary_length = tree->child->binary.binary_length;
-		tree->child->binary.binary_length = 0;
+		gda_binary_set_data (tree->binary, gda_binary_get_data (tree->child->binary), gda_binary_get_size (tree->child->binary));
+		gda_binary_reset_data (tree->child->binary);
 		rt_free_node (tree->child);
 		tree->child = NULL;
 		return TRUE;
@@ -855,6 +852,7 @@ rt_parse_text (const gchar *text)
 	TextTag *current = NULL;
 
 	retnode = g_new0 (RtNode, 1);
+	retnode->binary = gda_binary_new ();
 	contextnode = retnode;
 
 	ptr = text;
@@ -878,6 +876,7 @@ rt_parse_text (const gchar *text)
 			gchar *part;
 			RtNode *node;
 			node = g_new0 (RtNode, 1);
+			node->binary = gda_binary_new ();
 			node->parent = contextnode;
 			node->markup = RT_MARKUP_NONE;
 			if (prev == text)
@@ -906,6 +905,7 @@ rt_parse_text (const gchar *text)
 					else {
 						RtNode *n;
 						n = g_new0 (RtNode, 1);
+						n->binary = gda_binary_new ();
 						n->parent = contextnode;
 						n->markup = RT_MARKUP_PARA;
 						n->text = array [i];
@@ -919,7 +919,9 @@ rt_parse_text (const gchar *text)
 			else {
 				gchar *tmp;
 				tmp = remove_newlines_from_base64 (part);
-				node->binary.data = g_base64_decode_inplace (tmp, (gsize*) & node->binary.binary_length);
+				gsize size;
+				guchar *buffer = g_base64_decode_inplace (tmp, & size);
+				gda_binary_set_data (node->binary, buffer, size);
 			}
 		}
 		else {
@@ -961,7 +963,7 @@ rt_parse_text (const gchar *text)
 												   tmp, NULL);
 									g_free (tmp);
 								}
-								else if (lnode->binary.data) {
+								else if (gda_binary_get_data (lnode->binary)) {
 									TO_IMPLEMENT;
 								}
 								else
@@ -985,6 +987,7 @@ rt_parse_text (const gchar *text)
 			if (! tag_matched) {
 				RtNode *node;
 				node = g_new0 (RtNode, 1);
+				node->binary = gda_binary_new ();
 				node->parent = contextnode;
 				node->offset = ssol;
 				node->markup = internal_markup_to_external (mt, &(node->offset));
@@ -1001,6 +1004,7 @@ rt_parse_text (const gchar *text)
                                                 for (; i < node->offset; i++) {
                                                         RtNode *tmpn;
                                                         tmpn = g_new0 (RtNode, 1);
+                                                        tmpn->binary = gda_binary_new ();
                                                         tmpn->parent = contextnode;
                                                         tmpn->markup = RT_MARKUP_LIST;
                                                         tmpn->offset = i;
@@ -1018,6 +1022,7 @@ rt_parse_text (const gchar *text)
 						for (i = 0; i < node->offset; i++) {
                                                         RtNode *tmpn;
                                                         tmpn = g_new0 (RtNode, 1);
+                                                        tmpn->binary = gda_binary_new ();
                                                         tmpn->parent = contextnode;
                                                         tmpn->markup = RT_MARKUP_LIST;
                                                         tmpn->offset = i;
@@ -1169,9 +1174,9 @@ rich_text_node_to_docbook (RenderingContext *context, xmlNodePtr top_parent, RtN
 
 #ifdef HAVE_GDKPIXBUF
 		GdkPixdata pixdata;
-		if (rtnode->binary.data &&
-		    gdk_pixdata_deserialize (&pixdata, rtnode->binary.binary_length,
-					     (guint8*) rtnode->binary.data, NULL)) {
+		if (gda_binary_get_data (rtnode->binary) &&
+		    gdk_pixdata_deserialize (&pixdata, gda_binary_get_size (rtnode->binary),
+					     (guint8*) gda_binary_get_data (rtnode->binary), NULL)) {
                         GdkPixbuf *pixbuf;
                         pixbuf = gdk_pixbuf_from_pixdata (&pixdata, TRUE, NULL);
                         if (pixbuf) {
@@ -1189,9 +1194,9 @@ rich_text_node_to_docbook (RenderingContext *context, xmlNodePtr top_parent, RtN
 #endif
 
 		if (!saved) {
-			if (rtnode->binary.data &&
-			    g_file_set_contents (file, (gchar*) rtnode->binary.data,
-						 rtnode->binary.binary_length, NULL)) {
+			if (gda_binary_get_data (rtnode->binary) &&
+			    g_file_set_contents (file, (gchar*) gda_binary_get_data (rtnode->binary),
+						 gda_binary_get_size (rtnode->binary), NULL)) {
 				g_print ("Writen BIN file '%s'\n", file);
 				saved = TRUE;
 				type = 2;
@@ -1381,9 +1386,9 @@ rich_text_node_to_html (RenderingContext *context, xmlNodePtr top_parent, RtNode
 
 #ifdef HAVE_GDKPIXBUF
 		GdkPixdata pixdata;
-		if (rtnode->binary.data &&
-		    gdk_pixdata_deserialize (&pixdata, rtnode->binary.binary_length,
-					     (guint8*) rtnode->binary.data, NULL)) {
+		if (gda_binary_get_data (rtnode->binary) &&
+		    gdk_pixdata_deserialize (&pixdata, gda_binary_get_size (rtnode->binary),
+					     (guint8*) gda_binary_get_data (rtnode->binary), NULL)) {
                         GdkPixbuf *pixbuf;
                         pixbuf = gdk_pixbuf_from_pixdata (&pixdata, TRUE, NULL);
                         if (pixbuf) {
@@ -1401,9 +1406,9 @@ rich_text_node_to_html (RenderingContext *context, xmlNodePtr top_parent, RtNode
 #endif
 
 		if (!saved) {
-			if (rtnode->binary.data &&
-			    g_file_set_contents (file, (gchar*) rtnode->binary.data,
-						 rtnode->binary.binary_length, NULL)) {
+			if (gda_binary_get_data (rtnode->binary) &&
+			    g_file_set_contents (file, (gchar*) gda_binary_get_data (rtnode->binary),
+						 gda_binary_get_size (rtnode->binary), NULL)) {
 				g_print ("Writen BIN file '%s'\n", file);
 				saved = TRUE;
 				type = 2;
diff --git a/libgda-report/engine/rt-parser.h b/libgda-report/engine/rt-parser.h
index 1d5c530..ce14e11 100644
--- a/libgda-report/engine/rt-parser.h
+++ b/libgda-report/engine/rt-parser.h
@@ -56,7 +56,7 @@ struct _RtNode {
 	RtMarkup   markup;
 	gint       offset;
 	gchar     *text;
-	GdaBinary  binary;
+	GdaBinary *binary;
 };
 
 RtNode *rt_parse_text (const gchar *text);
diff --git a/libgda-ui/data-entries/common-bin.c b/libgda-ui/data-entries/common-bin.c
index 638d793..e9ab33e 100644
--- a/libgda-ui/data-entries/common-bin.c
+++ b/libgda-ui/data-entries/common-bin.c
@@ -81,9 +81,8 @@ file_load_cb (GtkWidget *button, BinMenu *menu)
 			if (g_file_get_contents (filename, &data, &length, &error)) {
 				GdaBinary *bin;
 				GValue *nvalue;
-				bin = g_new0 (GdaBinary, 1);
-				bin->data = (guchar*) data;
-				bin->binary_length = length;
+				bin = gda_binary_new ();
+				gda_binary_set_data (bin, (guchar*) data, length);
 				nvalue = gda_value_new (GDA_TYPE_BINARY);
 				gda_value_take_binary (nvalue, bin);
 
@@ -119,24 +118,24 @@ export_data (BinMenu *menu, const gchar *filename, GError **error)
 	if (menu->entry_type == GDA_TYPE_BINARY) {
 		const GdaBinary *bin;
 		bin = gda_value_get_binary (menu->tmpvalue);
-		allok = g_file_set_contents (filename, (gchar *) bin->data,
-					     bin->binary_length, error);
+		allok = g_file_set_contents (filename, (gchar *) gda_binary_get_data (bin),
+					     gda_binary_get_size (bin), error);
 	}
 	else if (menu->entry_type == GDA_TYPE_BLOB) {
 		GdaBlob *blob;
 		blob = (GdaBlob*) gda_value_get_blob (menu->tmpvalue);
-		if (blob->op) {
+		if (gda_blob_get_op (blob)) {
 			GValue *dest_value;
 			GdaBlob *dest_blob;
 
 			dest_value = gda_value_new_blob_from_file (filename);
 			dest_blob = (GdaBlob*) gda_value_get_blob (dest_value);
-			allok = gda_blob_op_write_all (dest_blob->op, (GdaBlob*) blob);
+			allok = gda_blob_op_write_all (gda_blob_get_op (dest_blob), (GdaBlob*) blob);
 			gda_value_free (dest_value);
 		}
 		else
-			allok = g_file_set_contents (filename, (gchar *) ((GdaBinary*)blob)->data,
-						     ((GdaBinary*)blob)->binary_length, error);
+			allok = g_file_set_contents (filename, (gchar *) gda_binary_get_data (gda_blob_get_binary (blob)),
+						     gda_binary_get_size (gda_blob_get_binary (blob)), error);
 	}
 	else
 		g_assert_not_reached ();
@@ -297,7 +296,7 @@ common_bin_get_description (BinMenu *binmenu)
 		if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
 			const GdaBinary *bin;
 			bin = gda_value_get_binary (value);
-			size = format_size (bin->binary_length);
+			size = format_size (gda_binary_get_size (bin));
 			g_string_append (string, size);
 			g_free (size);
 		}
@@ -305,10 +304,10 @@ common_bin_get_description (BinMenu *binmenu)
 			const GdaBlob *blob;
 			GdaBinary *bin;
 			blob = gda_value_get_blob (value);
-			bin = (GdaBinary *) blob;
-			if (blob->op) {
+			bin = gda_blob_get_binary (blob);
+			if (gda_blob_get_op (blob)) {
 				glong len;
-				len = gda_blob_op_get_length (blob->op);
+				len = gda_blob_op_get_length (gda_blob_get_op (blob));
 				if (len >= 0) {
 					size = format_size (len);
 					g_string_append (string, size);
@@ -318,7 +317,7 @@ common_bin_get_description (BinMenu *binmenu)
 					g_string_append (string, _("Unknown size"));
 			}
 			else {
-				size = format_size (bin->binary_length);
+				size = format_size (gda_binary_get_size (bin));
 				g_string_append (string, size);
 				g_free (size);
 			}
@@ -486,29 +485,29 @@ adjust_ctype (BinMenu *binmenu)
 		if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
 			const GdaBinary *bin;
 			bin = gda_value_get_binary (value);
-			binmenu->ctype = g_content_type_guess (NULL, bin->data, (gsize) bin->binary_length, NULL);
+			binmenu->ctype = g_content_type_guess (NULL, gda_binary_get_data (bin), (gsize) gda_binary_get_size (bin), NULL);
 		}
 		else if (G_VALUE_TYPE (value) == GDA_TYPE_BLOB) {
 			const GdaBlob *blob;
 			GdaBinary *bin;
 			blob = gda_value_get_blob (value);
-			bin = (GdaBinary *) blob;
-			if (blob->op) {
+			bin = gda_blob_get_binary (blob);
+			if (gda_blob_get_op (blob)) {
 				glong len;
-				len = gda_blob_op_get_length (blob->op);
+				len = gda_blob_op_get_length (gda_blob_get_op (blob));
 				if (len >= 0) {
 					GdaBlob *blob2;
 					blob2 = (GdaBlob*) gda_blob_copy ((gpointer) blob);
-					gda_blob_op_read (blob2->op, blob2, 0, 1024);
-					bin = (GdaBinary *) blob2;
-					binmenu->ctype = g_content_type_guess (NULL, bin->data,
-								      (gsize) bin->binary_length, NULL);
+					gda_blob_op_read (gda_blob_get_op (blob2), blob2, 0, 1024);
+					bin = gda_blob_get_binary (blob2);
+					binmenu->ctype = g_content_type_guess (NULL, gda_binary_get_data (bin),
+								      (gsize) gda_binary_get_size (bin), NULL);
 					gda_blob_free ((gpointer) blob2);
 				}
 			}
 			else
-				binmenu->ctype = g_content_type_guess (NULL, bin->data,
-								       (gsize) bin->binary_length, NULL);
+				binmenu->ctype = g_content_type_guess (NULL, gda_binary_get_data (bin),
+								       (gsize) gda_binary_get_size (bin), NULL);
 		}
 		else
 			g_assert_not_reached ();
diff --git a/libgda-ui/data-entries/plugins/common-pict.c b/libgda-ui/data-entries/plugins/common-pict.c
index efd7000..d75ac7a 100644
--- a/libgda-ui/data-entries/plugins/common-pict.c
+++ b/libgda-ui/data-entries/plugins/common-pict.c
@@ -53,24 +53,24 @@ common_pict_load_data (PictOptions *options, const GValue *value, PictBinData *b
 
 				blob = (GdaBlob *) gda_value_get_blob ((GValue *) value);
 				g_assert (blob);
-				bin = (GdaBinary *) blob;
-				if (blob->op &&
-				    (bin->binary_length != gda_blob_op_get_length (blob->op)))
-					gda_blob_op_read_all (blob->op, blob);
-				if (bin->binary_length > 0) {
-					bindata->data = g_new (guchar, bin->binary_length);
-					bindata->data_length = bin->binary_length;
-					memcpy (bindata->data, bin->data, bin->binary_length);
+				bin = gda_blob_get_binary (blob);
+				if (gda_blob_get_op (blob) &&
+				    (gda_binary_get_size (bin) != gda_blob_op_get_length (gda_blob_get_op (blob))))
+					gda_blob_op_read_all (gda_blob_get_op (blob), blob);
+				if (gda_binary_get_size (bin) > 0) {
+					bindata->data = g_new (guchar, gda_binary_get_size (bin));
+					bindata->data_length = gda_binary_get_size (bin);
+					memcpy (bindata->data, gda_binary_get_data (bin), gda_binary_get_size (bin));
 				}
 			}
 			else if (G_VALUE_TYPE ((GValue *) value) == GDA_TYPE_BINARY) {
 				GdaBinary *bin;
 
 				bin = (GdaBinary *) gda_value_get_binary ((GValue *) value);
-				if (bin && bin->binary_length > 0) {
-					bindata->data = g_new (guchar, bin->binary_length);
-					bindata->data_length = bin->binary_length;
-					memcpy (bindata->data, bin->data, bin->binary_length);
+				if (bin && gda_binary_get_size (bin) > 0) {
+					bindata->data = g_new (guchar, gda_binary_get_size (bin));
+					bindata->data_length = gda_binary_get_size (bin);
+					memcpy (bindata->data, gda_binary_get_data (bin), gda_binary_get_size (bin));
 				}
 				else {
 					*out_icon_name = "dialog-error";
@@ -588,19 +588,19 @@ common_pict_add_cached_pixbuf (PictOptions *options, const GValue *value, GdkPix
 		const GdaBinary *bin;
 		bin = gda_value_get_binary (value);
 		hash = g_new (gint, 1);
-		*hash = compute_hash (bin->data, bin->binary_length);
+		*hash = compute_hash (gda_binary_get_data (bin), gda_binary_get_size (bin));
 		g_hash_table_insert (options->pixbuf_hash, hash, g_object_ref (pixbuf));
 	}
 	else if (GDA_VALUE_HOLDS_BLOB (value)) {
 		const GdaBinary *bin;
 		const GdaBlob *blob;
 		blob = gda_value_get_blob (value);
-		bin = (GdaBinary *) blob;
+		bin = gda_binary_get_binary (blob);
 		if (bin) {
-			if (!bin->data && blob->op)
-				gda_blob_op_read_all (blob->op, (GdaBlob*) blob);
+			if (!gda_binary_get_data (bin) && gda_blob_get_op (blob))
+				gda_blob_op_read_all (gda_blob_get_op (blob), (GdaBlob*) blob);
 			hash = g_new (gint, 1);
-			*hash = compute_hash (bin->data, bin->binary_length);
+			*hash = compute_hash (gda_binary_get_data (bin), gda_binary_get_size (bin));
 			g_hash_table_insert (options->pixbuf_hash, hash, g_object_ref (pixbuf));
 		}
 	}
@@ -623,7 +623,7 @@ common_pict_fetch_cached_pixbuf (PictOptions *options, const GValue *value)
 		const GdaBinary *bin;
 		bin = gda_value_get_binary (value);
 		if (bin) {
-			hash = compute_hash (bin->data, bin->binary_length);
+			hash = compute_hash (gda_binary_get_data (bin), gda_binary_get_size (bin));
 			pixbuf = g_hash_table_lookup (options->pixbuf_hash, &hash);
 		}
 	}
@@ -631,11 +631,11 @@ common_pict_fetch_cached_pixbuf (PictOptions *options, const GValue *value)
 		const GdaBinary *bin;
 		const GdaBlob *blob;
 		blob = gda_value_get_blob (value);
-		bin = (GdaBinary *) blob;
+		bin = gda_blob_get_binary (blob);
 		if (bin) {
-			if (!bin->data && blob->op)
-				gda_blob_op_read_all (blob->op, (GdaBlob*) blob);
-			hash = compute_hash (bin->data, bin->binary_length);
+			if (!gda_binary_get_data (bin) && gda_blob_get_op (blob))
+				gda_blob_op_read_all (gda_blob_get_op (blob), (GdaBlob*) blob);
+			hash = compute_hash (gda_binary_get_data (bin), gda_binary_get_size (bin));
 			pixbuf = g_hash_table_lookup (options->pixbuf_hash, &hash);
 		}
 	}
diff --git a/libgda-ui/data-entries/plugins/gdaui-entry-pict.c b/libgda-ui/data-entries/plugins/gdaui-entry-pict.c
index 965e6e2..de74068 100644
--- a/libgda-ui/data-entries/plugins/gdaui-entry-pict.c
+++ b/libgda-ui/data-entries/plugins/gdaui-entry-pict.c
@@ -483,12 +483,12 @@ value_is_equal_to (GdauiEntryWrapper *mgwrap, const GValue *value)
 
 			blob = (GdaBlob*) gda_value_get_blob ((GValue *) value);
 			g_assert (blob);
-			bin = (GdaBinary *) blob;
-			if (blob->op &&
-			    (bin->binary_length != gda_blob_op_get_length (blob->op)))
-				gda_blob_op_read_all (blob->op, blob);
+			bin = gda_blob_get_binary (blob);
+			if (gda_blob_get_op (blob) &&
+			    (gda_binary_get_size (bin) != gda_blob_op_get_length (gda_blob_get_op (blob))))
+				gda_blob_op_read_all (gda_blob_get_op (blob), blob);
 			if (mgpict->priv->bindata.data)
-				return !memcmp (bin->data, mgpict->priv->bindata.data, MIN (mgpict->priv->bindata.data_length, bin->binary_length));
+				return !memcmp (gda_binary_get_data (bin), mgpict->priv->bindata.data, MIN (mgpict->priv->bindata.data_length, gda_binary_get_size (bin)));
 			else
 				return FALSE;
 		}
@@ -497,7 +497,7 @@ value_is_equal_to (GdauiEntryWrapper *mgwrap, const GValue *value)
 
 			bin = (GdaBinary *) gda_value_get_binary ((GValue *) value);
 			if (bin && mgpict->priv->bindata.data)
-				return !memcmp (bin->data, mgpict->priv->bindata.data, MIN (mgpict->priv->bindata.data_length, bin->binary_length));
+				return !memcmp (gda_binary_get_data (bin), mgpict->priv->bindata.data, MIN (mgpict->priv->bindata.data_length, gda_binary_get_size (bin)));
 			else
 				return FALSE;
 		}
diff --git a/libgda-ui/data-entries/plugins/gdaui-entry-rt.c b/libgda-ui/data-entries/plugins/gdaui-entry-rt.c
index 7739bb3..e1816d0 100644
--- a/libgda-ui/data-entries/plugins/gdaui-entry-rt.c
+++ b/libgda-ui/data-entries/plugins/gdaui-entry-rt.c
@@ -1,4 +1,4 @@
-/*
+  /*
  * Copyright (C) 2010 - 2015 Vivien Malerba <malerba@gnome-db.org>
  * Copyright (C) 2011 Murray Cumming <murrayc@murrayc.com>
  *
@@ -191,24 +191,24 @@ real_set_value (GdauiEntryWrapper *mgwrap, const GValue *value)
 				const GdaBlob *blob;
 				GdaBinary *bin;
 				blob = gda_value_get_blob (value);
-				bin = (GdaBinary *) blob;
-				if (blob->op &&
-				    (bin->binary_length != gda_blob_op_get_length (blob->op)))
-                                        gda_blob_op_read_all (blob->op, (GdaBlob*) blob);
-				if (g_utf8_validate ((gchar*) bin->data, bin->binary_length, NULL)) {
+				bin = gda_blob_get_binary (blob);
+				if (gda_blob_get_op (blob) &&
+				    (gda_binary_get_size (bin) != gda_blob_op_get_length (gda_blob_op (blob))))
+                                        gda_blob_op_read_all (gda_blob_get_op (blob), (GdaBlob*) blob);
+				if (g_utf8_validate ((gchar*) gda_binary_get_data (bin), gda_binary_get_size (bin), NULL)) {
 					gdaui_rt_editor_set_contents (GDAUI_RT_EDITOR (mgtxt->priv->view),
-								      (gchar*) bin->data,
-								      bin->binary_length);
+								      (gchar*) gda_binary_get_data (bin),
+								      gda_binary_get_size (bin));
 					done = TRUE;
 				}
 			}
 			else  if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
 				const GdaBinary *bin;
 				bin = gda_value_get_binary (value);
-				if (g_utf8_validate ((gchar*) bin->data, bin->binary_length, NULL)) {
+				if (g_utf8_validate ((gchar*) gda_binary_get_data (bin), gda_binary_get_size (bin), NULL)) {
 					gdaui_rt_editor_set_contents (GDAUI_RT_EDITOR (mgtxt->priv->view),
-								      (gchar*) bin->data, 
-								      bin->binary_length);
+								      (gchar*) gda_binary_get_data (bin), 
+								      gda_binary_get_size (bin));
 					done = TRUE;
 				}
 			}
diff --git a/libgda-ui/data-entries/plugins/gdaui-entry-text.c b/libgda-ui/data-entries/plugins/gdaui-entry-text.c
index e447b19..346655a 100644
--- a/libgda-ui/data-entries/plugins/gdaui-entry-text.c
+++ b/libgda-ui/data-entries/plugins/gdaui-entry-text.c
@@ -320,22 +320,22 @@ real_set_value (GdauiEntryWrapper *mgwrap, const GValue *value)
 				const GdaBlob *blob;
 				GdaBinary *bin;
 				blob = gda_value_get_blob (value);
-				bin = (GdaBinary *) blob;
-				if (blob->op &&
-				    (bin->binary_length != gda_blob_op_get_length (blob->op)))
-                                        gda_blob_op_read_all (blob->op, (GdaBlob*) blob);
-				if (g_utf8_validate ((gchar*) bin->data, bin->binary_length, NULL)) {
-					gtk_text_buffer_set_text (mgtxt->priv->buffer, (gchar*) bin->data, 
-								  bin->binary_length);
+				bin = gda_blob_get_binary (blob);
+				if (gda_blob_get_op (blob) &&
+				    (gda_binary_get_size (bin) != gda_blob_op_get_length (gda_blob_get_op (blob))))
+                                        gda_blob_op_read_all (gda_blob_get_op (blob), (GdaBlob*) blob);
+				if (g_utf8_validate ((gchar*) gda_binary_get_data (bin), gda_binary_get_size (bin), NULL)) {
+					gtk_text_buffer_set_text (mgtxt->priv->buffer, (gchar*) gda_binary_get_data (bin), 
+								  gda_binary_get_size (bin));
 					done = TRUE;
 				}
 			}
 			else  if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
 				const GdaBinary *bin;
 				bin = gda_value_get_binary (value);
-				if (g_utf8_validate ((gchar*) bin->data, bin->binary_length, NULL)) {
-					gtk_text_buffer_set_text (mgtxt->priv->buffer, (gchar*) bin->data, 
-								  bin->binary_length);
+				if (g_utf8_validate ((gchar*) gda_binary_get_data (bin), gda_binary_get_size (bin), NULL)) {
+					gtk_text_buffer_set_text (mgtxt->priv->buffer, (gchar*) gda_binary_get_data (bin), 
+								  gda_binary_get_size (bin));
 					done = TRUE;
 				}
 			}
diff --git a/libgda-ui/gdaui-raw-grid.c b/libgda-ui/gdaui-raw-grid.c
index 4bd1e96..88dcd99 100644
--- a/libgda-ui/gdaui-raw-grid.c
+++ b/libgda-ui/gdaui-raw-grid.c
@@ -1703,16 +1703,16 @@ menu_copy_row_cb (GtkWidget *widget, GdauiRawGrid *grid)
 			GdaBlob *blob;
 			blob = (GdaBlob *) gda_value_get_blob ((GValue *) cvalue);
 			g_assert (blob);
-			bin = (GdaBinary *) blob;
-			if (blob->op &&
-			    (bin->binary_length != gda_blob_op_get_length (blob->op)))
-				gda_blob_op_read_all (blob->op, blob);
+			bin = gda_blob_get_binary (blob);
+			if (gda_blob_get_op (blob) &&
+			    (gda_binary_get_size (bin) != gda_blob_op_get_length (gda_blob_get_op (blob))))
+				gda_blob_op_read_all (gda_blob_get_op (blob), blob);
 		}
 		if (bin) {
 			GdkPixbufLoader *loader;
 			GdkPixbuf *pixbuf = NULL;
 			loader = gdk_pixbuf_loader_new ();
-			if (gdk_pixbuf_loader_write (loader, bin->data, bin->binary_length, NULL)) {
+			if (gdk_pixbuf_loader_write (loader, gda_binary_get_data (bin), gda_binary_get_size (bin), NULL)) {
 				if (gdk_pixbuf_loader_close (loader, NULL)) {
 					pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
 					g_object_ref (pixbuf);
diff --git a/libgda/dir-blob-op.c b/libgda/dir-blob-op.c
index 15a7a79..617d871 100644
--- a/libgda/dir-blob-op.c
+++ b/libgda/dir-blob-op.c
@@ -180,6 +180,7 @@ gda_dir_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size)
 	GdaBinary *bin;
 	FILE *file;
 	size_t nread;
+	guchar *buffer;
 
 	g_return_val_if_fail (GDA_IS_DIR_BLOB_OP (op), -1);
 	dirop = GDA_DIR_BLOB_OP (op);
@@ -199,14 +200,11 @@ gda_dir_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size)
 		return -1;
 	}
 	
-	bin = (GdaBinary *) blob;
-	if (bin->data) {
-		g_free (bin->data);
-		bin->data = NULL;
-	}
-	bin->data = g_new0 (guchar, size);
-	nread = fread ((char *) (bin->data), 1, size, file);
-	bin->binary_length = nread;
+	bin = gda_blob_get_binary (blob);
+	gda_binary_reset_data (bin);
+	buffer = g_new0 (guchar, size);
+	nread = fread ((char *) (buffer), 1, size, file);
+	gda_binary_set_data (bin, buffer, nread);
 	fclose (file);
 
 	return nread;
@@ -240,25 +238,26 @@ gda_dir_blob_op_write (GdaBlobOp *op, GdaBlob *blob, glong offset)
 		}
 	}
 
-	if (blob->op && (blob->op != op)) {
+	if (gda_blob_get_op (blob) && (gda_blob_get_op (blob) != op)) {
 		/* use data through blob->op */
 #define buf_size 16384
 		gint nread = 0;
-		GdaBlob *tmpblob = g_new0 (GdaBlob, 1);
-		gda_blob_set_op (tmpblob, blob->op);
+		GdaBlob *tmpblob = gda_blob_new ();
+		gda_blob_set_op (tmpblob, gda_blob_get_op (blob));
 
 		nbwritten = 0;
 
-		for (nread = gda_blob_op_read (tmpblob->op, tmpblob, 0, buf_size);
+		for (nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, 0, buf_size);
 		     nread > 0;
-		     nread = gda_blob_op_read (tmpblob->op, tmpblob, nbwritten, buf_size)) {
-			GdaBinary *bin = (GdaBinary *) tmpblob;
+		     nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, nbwritten, buf_size)) {
+			GdaBinary *bin = gda_blob_get_binary (tmpblob);
 			glong tmp_written;
-			tmp_written = fwrite ((char *) (bin->data), sizeof (guchar), bin->binary_length, file);
-			if (tmp_written < bin->binary_length) {
+			guchar *buffer;
+			tmp_written = fwrite ((char *) (buffer), sizeof (guchar), gda_binary_get_size (bin), file);
+			if (tmp_written < gda_binary_get_size (bin)) {
 				/* error writing stream */
 				fclose (file);
-				gda_blob_free ((gpointer) tmpblob);
+				gda_blob_free (tmpblob);
 				return -1;
 			}
 			nbwritten += tmp_written;
@@ -267,11 +266,11 @@ gda_dir_blob_op_write (GdaBlobOp *op, GdaBlob *blob, glong offset)
 				break;
 		}
 		fclose (file);
-		gda_blob_free ((gpointer) tmpblob);
+		gda_blob_free (tmpblob);
 	}
 	else {
 		bin = (GdaBinary *) blob;
-		nbwritten = fwrite ((char *) (bin->data), 1, bin->binary_length, file);
+		nbwritten = fwrite ((char *) (gda_binary_get_data (bin)), 1, gda_binary_get_size (bin), file);
 		fclose (file);
 	}
 
diff --git a/libgda/gda-blob-op.c b/libgda/gda-blob-op.c
index 530495f..53c44b2 100644
--- a/libgda/gda-blob-op.c
+++ b/libgda/gda-blob-op.c
@@ -332,9 +332,9 @@ gda_blob_op_read_all (GdaBlobOp *op, GdaBlob *blob)
 	g_return_val_if_fail (GDA_IS_BLOB_OP (op), FALSE);
 	g_return_val_if_fail (blob, FALSE);
 
-	len = gda_blob_op_get_length (blob->op);
+	len = gda_blob_op_get_length (gda_blob_get_op (blob));
 	if (len >= 0)
-		return (gda_blob_op_read (blob->op, blob, 0, len) < 0) ? FALSE : TRUE;
+		return (gda_blob_op_read (gda_blob_get_op (blob), blob, 0, len) < 0) ? FALSE : TRUE;
 	else
 		return FALSE;
 }
diff --git a/libgda/gda-data-model-dir.c b/libgda/gda-data-model-dir.c
index ee05652..e63177e 100644
--- a/libgda/gda-data-model-dir.c
+++ b/libgda/gda-data-model-dir.c
@@ -832,7 +832,7 @@ gda_data_model_dir_get_value_at (GdaDataModel *model, gint col, gint row, GError
 				GdaBlobOp *op;
 				gchar *filename;
 
-				blob = g_new0 (GdaBlob, 1);
+				blob = gda_blob_new ();
 
 				/* file mapping in mem */
 				filename = compute_filename (imodel, frow);
@@ -1029,8 +1029,8 @@ gda_data_model_dir_set_values (GdaDataModel *model, gint row, GList *values, GEr
 						if (frow->data_value) {
 							GdaBlob *blob;
 							blob = (GdaBlob *) gda_value_get_blob (frow->data_value);
-							if (blob && blob->op)
-								_gda_dir_blob_set_filename (GDA_DIR_BLOB_OP (blob->op),
+							if (blob && gda_blob_get_op (blob))
+								_gda_dir_blob_set_filename (GDA_DIR_BLOB_OP (gda_blob_get_op (blob)),
 											   new_filename);
 						}
 					}
@@ -1105,8 +1105,8 @@ gda_data_model_dir_set_values (GdaDataModel *model, gint row, GList *values, GEr
 				if (frow->data_value) {
 					GdaBlob *blob;
 					blob = (GdaBlob *) gda_value_get_blob (frow->data_value);
-					if (blob && blob->op)
-						_gda_dir_blob_set_filename (GDA_DIR_BLOB_OP (blob->op),
+					if (blob && gda_blob_get_op (blob))
+						_gda_dir_blob_set_filename (GDA_DIR_BLOB_OP (gda_blob_get_op (blob)),
 									   new_filename);
 				}
 			}
@@ -1125,7 +1125,7 @@ gda_data_model_dir_set_values (GdaDataModel *model, gint row, GList *values, GEr
 			}
 			else if (gda_value_is_null (value)) {
 				/* create a new empty blob */
-				blob = g_new0 (GdaBlob, 1);
+				blob = gda_blob_new ();
 			}
 
 			if (blob) {
@@ -1239,11 +1239,11 @@ gda_data_model_dir_append_values (GdaDataModel *model, const GList *values, GErr
 			gboolean bin_to_free = FALSE;
 			complete_filename = g_build_filename (dirname, filename, NULL);
 			if (!bin_data) {
-				bin_data = g_new0 (GdaBinary, 1);
+				bin_data = gda_binary_new ();
 				bin_to_free = TRUE;
 			}
-			if (g_file_set_contents (complete_filename, (gchar *) bin_data->data,
-						 bin_data->binary_length, NULL)) {
+			if (g_file_set_contents (complete_filename, (gchar *) gda_binary_get_data (bin_data),
+						 gda_binary_get_size (bin_data), NULL)) {
 				FileRow *row;
 
 				row = file_row_new ();
diff --git a/libgda/gda-data-pivot.c b/libgda/gda-data-pivot.c
index 56bdece..a2896c2 100644
--- a/libgda/gda-data-pivot.c
+++ b/libgda/gda-data-pivot.c
@@ -2035,17 +2035,19 @@ _gda_value_hash (gconstpointer key)
 		if (vt == GDA_TYPE_BLOB) {
 			GdaBlob *blob;
 			blob = (GdaBlob*) gda_value_get_blob ((GValue *) v);
-			bin = (GdaBinary *) blob;
-			if (blob->op &&
-			    (bin->binary_length != gda_blob_op_get_length (blob->op)))
-				gda_blob_op_read_all (blob->op, blob);
+			bin = gda_blob_get_binary (blob);
+			if (gda_blob_get_op (blob) &&
+			    (gda_binary_get_size (bin) != gda_blob_op_get_length (gda_blob_get_op (blob))))
+				gda_blob_op_read_all (gda_blob_get_op (blob), blob);
 		}
 		else
 			bin = gda_value_get_binary ((GValue *) v);
 		if (bin) {
 			glong l;
-			for (l = 0; l < bin->binary_length; l++)
-				res += (guint) bin->data [l];
+			for (l = 0; l < gda_binary_get_size (bin); l++) {
+			  guchar* p = gda_binary_get_data (bin);
+				res += (guint) p[l];
+			}
 		}
 	}
 	else {
diff --git a/libgda/gda-util.c b/libgda/gda-util.c
index 7a76e12..8b96a29 100644
--- a/libgda/gda-util.c
+++ b/libgda/gda-util.c
@@ -506,10 +506,10 @@ gda_utility_data_model_dump_data_to_xml (GdaDataModel *model, xmlNodePtr parent,
 						/* force reading the whole blob */
 						const GdaBlob *blob = gda_value_get_blob (value);
 						if (blob) {
-							const GdaBinary *bin = &(blob->data);
-							if (blob->op && 
-							    (bin->binary_length != gda_blob_op_get_length (blob->op)))
-								gda_blob_op_read_all (blob->op, (GdaBlob*) blob);
+							const GdaBinary *bin = gda_blob_get_binary (blob);
+							if (gda_blob_get_op (blob) && 
+							    (gda_binary_get_size (bin) != gda_blob_op_get_length (gda_blob_get_op (blob))))
+								gda_blob_op_read_all (gda_blob_get_op (blob), (GdaBlob*) blob);
 						}
 						str = gda_value_stringify (value);
 					}
diff --git a/libgda/gda-value.c b/libgda/gda-value.c
index 80076f4..532c19b 100644
--- a/libgda/gda-value.c
+++ b/libgda/gda-value.c
@@ -394,6 +394,13 @@ gda_default_get_type (void)
 }
 
 
+// GdaBinary
+
+struct _GdaBinary {
+	guchar *data;
+	glong   binary_length;
+};
+
 /*
  * Register the GdaBinary type in the GType system
  */
@@ -450,6 +457,126 @@ gda_binary_get_type (void)
 	return type;
 }
 
+
+/*
+ * Register the GdaBlob type in the GType system
+ */
+/* Transform a String GValue to a GdaBlob*/
+static void
+string_to_blob (const GValue *src, GValue *dest)
+{
+	GdaBlob *blob;
+	const gchar *as_string;
+
+	g_return_if_fail (G_VALUE_HOLDS_STRING (src) &&
+			  GDA_VALUE_HOLDS_BLOB (dest));
+
+	as_string = g_value_get_string (src);
+
+	blob = gda_string_to_blob (as_string);
+	g_return_if_fail (blob);
+	gda_value_take_blob (dest, blob);
+}
+
+static void
+blob_to_string (const GValue *src, GValue *dest)
+{
+	gchar *str;
+
+	g_return_if_fail (G_VALUE_HOLDS_STRING (dest) &&
+			  GDA_VALUE_HOLDS_BLOB (src));
+
+	str = gda_blob_to_string ((GdaBlob *) gda_value_get_blob ((GValue *) src), 0);
+
+	g_value_take_string (dest, str);
+}
+
+/**
+ * gda_binary_new:
+ *
+ * Creates a new #GdaBinary coping data.
+ *
+ * Returns: (transfer full): the newly created #GdaBinary.
+ */
+GdaBinary*
+gda_binary_new (void)
+{
+	GdaBinary *binary = g_new0 (GdaBinary, 1);
+
+  binary->data = NULL;
+  binary->binary_length = 0;
+
+  return (GdaBinary*) binary;
+}
+
+/**
+ * gda_binary_set_data:
+ * @val: (array length=size): value to be copied by #GdaBinary.
+ * @size: the size of the memory pool pointer to by @val.
+ *
+ * Set binary data to a #GdaBinary, holding a copy of the data.
+ *
+ * Returns: (transfer full): the newly created #GdaBinary.
+ */
+void
+gda_binary_set_data (GdaBinary *binary, const guchar *val, glong size)
+{
+	g_return_if_fail (binary);
+	g_return_if_fail (val);
+  if (binary->data != NULL)
+    g_free (binary->data);
+  binary->data = g_memdup (val, size);
+  binary->binary_length = size;
+}
+
+
+/**
+ * gda_binary_get_data:
+ *
+ * Returns: (transfer none): associated data to #GdaBinary.
+ */
+gpointer
+gda_binary_get_data (GdaBinary *binary)
+{
+	g_return_val_if_fail (binary, NULL);
+
+  return binary->data;
+}
+
+
+
+/**
+ * gda_binary_reset_data:
+ *
+ * Frees data referenced by #GdaBinary
+ *
+ */
+void
+gda_binary_reset_data (GdaBinary *binary)
+{
+	g_return_if_fail (binary);
+
+  if (binary->data != NULL)
+    g_free (binary->data);
+  binary->data = NULL;
+  binary->binary_length = 0;
+}
+
+
+/**
+ * gda_binary_get_size:
+ *
+ * Returns: size of associated data to #GdaBinary or -1 in case of error.
+ */
+glong
+gda_binary_get_size (GdaBinary *binary)
+{
+	g_return_val_if_fail (binary, -1);
+
+  return binary->binary_length;
+}
+
+
 /**
  * gda_binary_copy:
  * @boxed: source to get a copy from.
@@ -460,10 +587,9 @@ gda_binary_get_type (void)
  *
  * Free-function: gda_binary_free
  */
-gpointer
-gda_binary_copy (gpointer boxed)
+GdaBinary*
+gda_binary_copy (GdaBinary *src)
 {
-	GdaBinary *src = (GdaBinary*) boxed;
 	GdaBinary *copy = NULL;
 
 	g_return_val_if_fail (src, NULL);
@@ -482,48 +608,53 @@ gda_binary_copy (gpointer boxed)
  * Deallocates all memory associated to the given #GdaBinary.
  */
 void
-gda_binary_free (gpointer boxed)
+gda_binary_free (GdaBinary *binary)
 {
-	GdaBinary *binary = (GdaBinary*) boxed;
-
 	g_return_if_fail (binary);
 
-	g_free (binary->data);
+	if (binary->data)
+	  g_free (binary->data);
 	g_free (binary);
 }
 
-/*
- * Register the GdaBlob type in the GType system
+/**
+ * gda_value_new_binary: (skip)
+ * @val: value to set for the new #GValue.
+ * @size: the size of the memory pool pointer to by @val.
+ *
+ * Makes a new #GValue of type #GDA_TYPE_BINARY with value @val.
+ *
+ * Returns: (transfer full): the newly created #GValue.
+ *
+ * Free-function: gda_value_free
  */
-/* Transform a String GValue to a GdaBlob*/
-static void
-string_to_blob (const GValue *src, GValue *dest)
+GValue *
+gda_value_new_binary (const guchar *val, glong size)
 {
-	GdaBlob *blob;
-	const gchar *as_string;
+	GValue *value;
+	GdaBinary binary;
 
-	g_return_if_fail (G_VALUE_HOLDS_STRING (src) &&
-			  GDA_VALUE_HOLDS_BLOB (dest));
+	/* We use the const on the function parameter to make this clearer,
+	 * but it would be awkward to keep the const in the struct.
+         */
+        binary.data = (guchar*)val;
+        binary.binary_length = size;
 
-	as_string = g_value_get_string (src);
+        value = g_new0 (GValue, 1);
+        gda_value_set_binary (value, &binary);
 
-	blob = gda_string_to_blob (as_string);
-	g_return_if_fail (blob);
-	gda_value_take_blob (dest, blob);
+        return value;
 }
 
-static void
-blob_to_string (const GValue *src, GValue *dest)
-{
-	gchar *str;
 
-	g_return_if_fail (G_VALUE_HOLDS_STRING (dest) &&
-			  GDA_VALUE_HOLDS_BLOB (src));
 
-	str = gda_blob_to_string ((GdaBlob *) gda_value_get_blob ((GValue *) src), 0);
+// GdaBlob
+
+struct _GdaBlob {
+	GdaBinary *data;
+	GdaBlobOp *op;
+};
 
-	g_value_take_string (dest, str);
-}
 
 GType
 gda_blob_get_type (void)
@@ -548,31 +679,74 @@ gda_blob_get_type (void)
 }
 
 /**
+ * gda_blob_new:
+ *
+ * Creates a new #GdaBlob.
+
+ * Returns: (transfer full): a newly allocated #GdaBlob.
+ */
+GdaBlob*
+gda_blob_new (void)
+{
+	GdaBlob* blob = g_new0 (GdaBlob, 1);
+	blob->data = gda_binary_new ();
+
+	return (GdaBlob*) blob;
+}
+
+/**
+ * gda_blob_get_binary:
+ *
+ * Returns: (transfer none): associated #GdaBinary.
+ */
+GdaBinary*
+gda_blob_get_binary (GdaBlob *blob)
+{
+	g_return_val_if_fail (blob, NULL);
+
+	return blob->data;
+}
+
+/**
+ * gda_blob_get_op:
+ *
+ * Returns: (transfer none): associated #GdaBlobOp.
+ */
+GdaBlobOp*
+gda_blob_get_op (GdaBlob *blob)
+{
+	g_return_val_if_fail (blob, NULL);
+
+	return blob->op;
+}
+
+
+/**
  * gda_blob_copy:
- * @boxed: source to get a copy from.
+ * @src: source to get a copy from.
  *
  * Creates a new #GdaBlob structure from an existing one.
 
  * Returns: (transfer full): a newly allocated #GdaBlob which contains a copy of information in @boxed.
  *
- * Free-function: gda_blob_free
  */
-gpointer
-gda_blob_copy (gpointer boxed)
+GdaBlob*
+gda_blob_copy (GdaBlob *src)
 {
-	GdaBlob *src = (GdaBlob*) boxed;
 	GdaBlob *copy = NULL;
 
-	g_return_val_if_fail (src, NULL);
+	g_return_val_if_fail (src != NULL, NULL);
 
 	copy = g_new0 (GdaBlob, 1);
-	if (((GdaBinary *)src)->data) {
-		((GdaBinary *)copy)->data = g_memdup (((GdaBinary *)src)->data, ((GdaBinary *)src)->binary_length);
-		((GdaBinary *)copy)->binary_length = ((GdaBinary *)src)->binary_length;
-	}
+	copy->data = gda_binary_new ();
+	if (src->data == NULL) return copy;
+	if (src->data->data)
+	  gda_binary_set_data (copy->data,
+	                      gda_binary_get_data (src->data),
+	                      gda_binary_get_size (src->data));
 	gda_blob_set_op (copy, src->op);
 
-	return copy;
+	return (GdaBlob*) copy;
 }
 
 /**
@@ -582,17 +756,16 @@ gda_blob_copy (gpointer boxed)
  * Deallocates all memory associated to the given #GdaBlob.
  */
 void
-gda_blob_free (gpointer boxed)
+gda_blob_free (GdaBlob *blob)
 {
-	GdaBlob *blob = (GdaBlob*) boxed;
-
 	g_return_if_fail (blob);
 
 	if (blob->op) {
 		g_object_unref (blob->op);
 		blob->op = NULL;
 	}
-	gda_binary_free ((GdaBinary *) blob);
+	gda_binary_free (blob->data);
+	g_free (blob);
 }
 
 /**
@@ -605,6 +778,8 @@ gda_blob_free (gpointer boxed)
 void
 gda_blob_set_op (GdaBlob *blob, GdaBlobOp *op)
 {
+	g_return_if_fail (blob);
+
 	if (blob->op) {
 		g_object_unref (blob->op);
 		blob->op = NULL;
@@ -1539,34 +1714,7 @@ gda_value_new_default (const gchar *default_val)
 	return value;
 }
 
-/**
- * gda_value_new_binary: (skip)
- * @val: value to set for the new #GValue.
- * @size: the size of the memory pool pointer to by @val.
- *
- * Makes a new #GValue of type #GDA_TYPE_BINARY with value @val.
- *
- * Returns: (transfer full): the newly created #GValue.
- *
- * Free-function: gda_value_free
- */
-GValue *
-gda_value_new_binary (const guchar *val, glong size)
-{
-	GValue *value;
-	GdaBinary binary;
-
-	/* We use the const on the function parameter to make this clearer,
-	 * but it would be awkward to keep the const in the struct.
-         */
-        binary.data = (guchar*)val;
-        binary.binary_length = size;
-
-        value = g_new0 (GValue, 1);
-        gda_value_set_binary (value, &binary);
 
-        return value;
-}
 
 /**
  * gda_value_new_blob: (skip)
@@ -1586,18 +1734,14 @@ gda_value_new_blob (const guchar *val, glong size)
 	GdaBlob *blob;
 	GdaBinary *bin;
 
-	blob = g_new0 (GdaBlob, 1);
-	bin = (GdaBinary*)(blob);
-	bin->data = g_new (guchar, size);
-        memcpy ((gpointer) bin->data, (gpointer) val, size); /* Flawfinder: ignore */
-        bin->binary_length = size;
-	blob->op = NULL;
-
-        value = g_new0 (GValue, 1);
+	blob = gda_blob_new ();
+	bin = gda_blob_get_binary (blob);
+	gda_binary_set_data (bin, val, size);
+  value = g_new0 (GValue, 1);
 	g_value_init (value, GDA_TYPE_BLOB);
-        g_value_take_boxed (value, blob);
+  g_value_take_boxed (value, blob);
 
-        return value;
+  return value;
 }
 
 /**
diff --git a/libgda/gda-value.h b/libgda/gda-value.h
index 1037aaf..b915d2d 100644
--- a/libgda/gda-value.h
+++ b/libgda/gda-value.h
@@ -138,10 +138,22 @@ typedef struct {
  * @data: (array length=binary_length): the actual data as an array
  * @binary_length: length of @data
  */
-typedef struct {
-	guchar *data;
-	glong   binary_length;
-} GdaBinary;
+typedef struct _GdaBinary GdaBinary;
+
+GValue*                           gda_value_new_binary (const guchar *val, glong size);
+const GdaBinary*									gda_value_get_binary (const GValue *value);
+void                              gda_value_set_binary (GValue *value, const GdaBinary *binary);
+void                              gda_value_take_binary (GValue *value, GdaBinary *binary);
+
+
+GType                             gda_binary_get_type (void) G_GNUC_CONST;
+GdaBinary*                        gda_binary_new (void);
+glong                             gda_binary_get_size (GdaBinary* binary);
+gpointer                          gda_binary_get_data (GdaBinary* binary);
+void                              gda_binary_reset_data (GdaBinary* binary);
+void                              gda_binary_set_data (GdaBinary *binary, const guchar *val, glong size);
+GdaBinary*                        gda_binary_copy (GdaBinary *src);
+void                              gda_binary_free (GdaBinary *binary);
 
 /**
  * GdaBlob:
@@ -152,10 +164,17 @@ typedef struct {
  * @op is generally set up by database providers when giving access to an existing BLOB in
  * a database, but can be modified if needed using gda_blob_set_op().
  */
-typedef struct {
-	GdaBinary  data;
-	GdaBlobOp *op;
-} GdaBlob;
+typedef struct _GdaBlob GdaBlob;
+
+
+GType                             gda_blob_get_type (void) G_GNUC_CONST;
+GdaBlob*                          gda_blob_new (void);
+GdaBinary*                        gda_blob_get_binary (GdaBlob *blob);
+GdaBlobOp*                        gda_blob_get_op (GdaBlob *blob);
+GdaBlob*                          gda_blob_copy (GdaBlob *src);
+void                              gda_blob_free (GdaBlob *blob);
+void                              gda_blob_set_op (GdaBlob *blob, GdaBlobOp *op);
+
 
 #define gda_value_isa(value, type) (G_VALUE_HOLDS(value, type))
 
@@ -200,7 +219,6 @@ GValue                           *gda_value_new (GType type);
 
 GValue                           *gda_value_new_null (void);
 GValue                           *gda_value_new_default (const gchar *default_val);
-GValue                           *gda_value_new_binary (const guchar *val, glong size);
 GValue                           *gda_value_new_blob (const guchar *val, glong size);
 GValue                           *gda_value_new_blob_from_file (const gchar *filename);
 GValue                           *gda_value_new_time_from_timet (time_t val);
@@ -216,9 +234,6 @@ gboolean                          gda_value_is_null (const GValue *value);
 gboolean                          gda_value_is_number (const GValue *value); 
 GValue                           *gda_value_copy (const GValue *value);
 
-const GdaBinary         *gda_value_get_binary (const GValue *value);
-void                              gda_value_set_binary (GValue *value, const GdaBinary *binary);
-void                              gda_value_take_binary (GValue *value, GdaBinary *binary);
 
 const GdaBlob           *gda_value_get_blob (const GValue *value);
 void                              gda_value_set_blob (GValue *value, const GdaBlob *blob);
@@ -280,15 +295,6 @@ GType                             gda_geometricpoint_get_type (void) G_GNUC_CONS
 gpointer                          gda_geometricpoint_copy (gpointer boxed);
 void                              gda_geometricpoint_free (gpointer boxed);
 
-GType                             gda_binary_get_type (void) G_GNUC_CONST;
-gpointer                          gda_binary_copy (gpointer boxed);
-void                              gda_binary_free (gpointer boxed);
-
-GType                             gda_blob_get_type (void) G_GNUC_CONST;
-gpointer                          gda_blob_copy (gpointer boxed);
-void                              gda_blob_free (gpointer boxed);
-void                              gda_blob_set_op (GdaBlob *blob, GdaBlobOp *op);
-
 GType                             gda_short_get_type (void) G_GNUC_CONST;
 GType                             gda_ushort_get_type (void) G_GNUC_CONST;
 
diff --git a/libgda/gda-xa-transaction.c b/libgda/gda-xa-transaction.c
index 5b56ff6..d6bb8b0 100644
--- a/libgda/gda-xa-transaction.c
+++ b/libgda/gda-xa-transaction.c
@@ -293,9 +293,8 @@ gda_xa_transaction_register_connection  (GdaXaTransaction *xa_trans, GdaConnecti
 
 	const GdaBinary *ebranch = g_hash_table_lookup (xa_trans->priv->cnc_hash, cnc);
 	if (ebranch) {
-		bin = g_new0 (GdaBinary, 1);
-		bin->data = (guchar*) g_strdup (branch);
-		bin->binary_length = strlen (branch) + 1;
+		bin = gda_binary_new ();
+		gda_binary_set_data (bin, branch, strlen (branch) + 1);
 		g_hash_table_insert (xa_trans->priv->cnc_hash, cnc, bin);
 		return TRUE;
 	}
@@ -325,9 +324,8 @@ gda_xa_transaction_register_connection  (GdaXaTransaction *xa_trans, GdaConnecti
 			xa_trans->priv->non_xa_cnc = cnc;
 	}
 
-	bin = g_new0 (GdaBinary, 1);
-	bin->data = (guchar*) g_strdup (branch);
-	bin->binary_length = strlen (branch) + 1;
+	bin = gda_binary_new ();
+	gda_binary_set_data (bin, branch, strlen (branch) + 1);
 	xa_trans->priv->cnc_list = g_list_prepend (xa_trans->priv->cnc_list, cnc);
 	g_hash_table_insert (xa_trans->priv->cnc_hash, cnc, bin);
 	g_object_ref (cnc);
@@ -388,7 +386,7 @@ gda_xa_transaction_begin  (GdaXaTransaction *xa_trans, GError **error)
 			const GdaBinary *branch;
 			branch = g_hash_table_lookup (xa_trans->priv->cnc_hash, cnc);
 			memcpy (xa_trans->priv->xid.data + xa_trans->priv->xid.gtrid_length, /* Flawfinder: ignore */
-				branch->data, branch->binary_length);
+				gda_binary_get_data (branch), gda_binary_get_size (branch));
 			if (! _gda_server_provider_xa_start (prov, cnc, &(xa_trans->priv->xid), error))
 				break;
 		}
@@ -412,7 +410,7 @@ gda_xa_transaction_begin  (GdaXaTransaction *xa_trans, GError **error)
 				const GdaBinary *branch;
 				branch = g_hash_table_lookup (xa_trans->priv->cnc_hash, cnc);
 				memcpy (xa_trans->priv->xid.data + xa_trans->priv->xid.gtrid_length, /* Flawfinder: ignore */
-					branch->data, branch->binary_length);
+					gda_binary_get_data (branch), gda_binary_get_size (branch));
 				_gda_server_provider_xa_rollback (prov, cnc, &(xa_trans->priv->xid), NULL);
 			}
 			else {
@@ -469,7 +467,7 @@ gda_xa_transaction_commit (GdaXaTransaction *xa_trans, GSList **cnc_to_recover,
 
 		branch = g_hash_table_lookup (xa_trans->priv->cnc_hash, cnc);
 		memcpy (xa_trans->priv->xid.data + xa_trans->priv->xid.gtrid_length, /* Flawfinder: ignore */
-			branch->data, branch->binary_length);
+			gda_binary_get_data (branch), gda_binary_get_size (branch));
 
 		if (!_gda_server_provider_xa_end (prov, cnc, &(xa_trans->priv->xid), error))
 			break;
@@ -491,7 +489,7 @@ gda_xa_transaction_commit (GdaXaTransaction *xa_trans, GSList **cnc_to_recover,
 				prov = gda_connection_get_provider (cnc);
 				branch = g_hash_table_lookup (xa_trans->priv->cnc_hash, cnc);
 				memcpy (xa_trans->priv->xid.data + xa_trans->priv->xid.gtrid_length, /* Flawfinder: ignore */
-					branch->data, branch->binary_length);
+					gda_binary_get_data (branch), gda_binary_get_size (branch));
 				_gda_server_provider_xa_rollback (prov, cnc, &(xa_trans->priv->xid), NULL);
 			}
 		}
@@ -516,7 +514,7 @@ gda_xa_transaction_commit (GdaXaTransaction *xa_trans, GSList **cnc_to_recover,
 				prov = gda_connection_get_provider (cnc);
 				branch = g_hash_table_lookup (xa_trans->priv->cnc_hash, cnc);
 				memcpy (xa_trans->priv->xid.data + xa_trans->priv->xid.gtrid_length, /* Flawfinder: ignore */
-					branch->data, branch->binary_length);
+					gda_binary_get_data (branch), gda_binary_get_size (branch));
 				_gda_server_provider_xa_rollback (prov, cnc, &(xa_trans->priv->xid), NULL);
 			}
 		}
@@ -535,7 +533,7 @@ gda_xa_transaction_commit (GdaXaTransaction *xa_trans, GSList **cnc_to_recover,
 		prov = gda_connection_get_provider (cnc);
 		branch = g_hash_table_lookup (xa_trans->priv->cnc_hash, cnc);
 		memcpy (xa_trans->priv->xid.data + xa_trans->priv->xid.gtrid_length, /* Flawfinder: ignore */
-			branch->data, branch->binary_length);
+			gda_binary_get_data (branch), gda_binary_get_size (branch));
 		if (! _gda_server_provider_xa_commit (prov, cnc, &(xa_trans->priv->xid), error) &&
 		    cnc_to_recover)
 			*cnc_to_recover = g_slist_prepend (*cnc_to_recover, cnc);
@@ -572,7 +570,7 @@ gda_xa_transaction_rollback (GdaXaTransaction *xa_trans, GError **error)
 			const GdaBinary *branch;
 			branch = g_hash_table_lookup (xa_trans->priv->cnc_hash, cnc);
 			memcpy (xa_trans->priv->xid.data + xa_trans->priv->xid.gtrid_length, /* Flawfinder: ignore */
-				branch->data, branch->binary_length);
+				gda_binary_get_data (branch), gda_binary_get_size (branch));
 			GError *lerror = NULL;
 			_gda_server_provider_xa_rollback (prov, cnc, &(xa_trans->priv->xid), &lerror);
 			if (error && !*error)
@@ -628,7 +626,7 @@ gda_xa_transaction_commit_recovered (GdaXaTransaction *xa_trans, GSList **cnc_to
 
 			branch = g_hash_table_lookup (xa_trans->priv->cnc_hash, cnc);
 			memcpy (xa_trans->priv->xid.data + xa_trans->priv->xid.gtrid_length, /* Flawfinder: ignore */
-				branch->data, branch->binary_length);
+				gda_binary_get_data (branch), gda_binary_get_size (branch));
 			for (xlist = recov_xid_list; xlist; xlist = xlist->next) {
 				GdaXaTransactionId *xid = (GdaXaTransactionId*) xlist->data;
 				if (!xid)
diff --git a/libgda/handlers/gda-handler-bin.c b/libgda/handlers/gda-handler-bin.c
index 88fb8ae..5dfef1d 100644
--- a/libgda/handlers/gda-handler-bin.c
+++ b/libgda/handlers/gda-handler-bin.c
@@ -186,9 +186,9 @@ gda_handler_bin_get_sql_from_value (G_GNUC_UNUSED GdaDataHandler *iface, const G
 		GdaBinary *bin;
 		blob = (GdaBlob*) gda_value_get_blob ((GValue *) value);
 		bin = (GdaBinary *) blob;
-		if (blob->op &&
-		    (bin->binary_length != gda_blob_op_get_length (blob->op)))
-			gda_blob_op_read_all (blob->op, blob);
+		if (gda_blob_get_op (blob) &&
+		    (gda_binary_get_size (bin) != gda_blob_op_get_length (gda_blob_get_op (blob))))
+			gda_blob_op_read_all (gda_blob_get_op (blob), blob);
 
 		gchar *str, *str2;
 		str = gda_binary_to_string (bin, 0);
@@ -213,8 +213,8 @@ gda_handler_bin_get_str_from_value (G_GNUC_UNUSED GdaDataHandler *iface, const G
 		else {
 			GdaBlob *blob;
 			blob = (GdaBlob*) gda_value_get_blob ((GValue *) value);
-			if (blob->op)
-				gda_blob_op_read_all (blob->op, blob);
+			if (gda_blob_get_op (blob))
+				gda_blob_op_read_all (gda_blob_get_op (blob), blob);
 			retval = gda_binary_to_string ((GdaBinary *) blob, 0);
 		}
 	}
diff --git a/libgda/sqlite/gda-sqlite-blob-op.c b/libgda/sqlite/gda-sqlite-blob-op.c
index d973253..e7fade4 100644
--- a/libgda/sqlite/gda-sqlite-blob-op.c
+++ b/libgda/sqlite/gda-sqlite-blob-op.c
@@ -198,6 +198,7 @@ gda_sqlite_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size)
 {
 	GdaSqliteBlobOp *bop;
 	GdaBinary *bin;
+	gpointer buffer = NULL;
 	int rc;
 
 	g_return_val_if_fail (GDA_IS_SQLITE_BLOB_OP (op), -1);
@@ -213,11 +214,8 @@ gda_sqlite_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size)
 	if (size > G_MAXINT)
 		return -1;
 
-	bin = (GdaBinary *) blob;
-	if (bin->data) 
-		g_free (bin->data);
-	bin->data = g_new0 (guchar, size);
-	bin->binary_length = 0;
+	bin = gda_blob_get_binary (blob);
+	gda_binary_set_data (bin, (guchar*) "", 0);
 
 	/* fetch blob data using C API into bin->data, and set bin->binary_length */
 	int rsize;
@@ -235,16 +233,15 @@ gda_sqlite_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size)
 
 	if (len - offset < rsize)
 		rsize = len - offset;
-
-	rc = SQLITE3_CALL (sqlite3_blob_read) (bop->priv->sblob, bin->data, rsize, offset);
+  
+	rc = SQLITE3_CALL (sqlite3_blob_read) (bop->priv->sblob, buffer, rsize, offset);
 	if (rc != SQLITE_OK) {
-		g_free (bin->data);
-		bin->data = NULL;
+		gda_binary_reset_data (bin);
 		return -1;
 	}
-	bin->binary_length = rsize;
+	gda_binary_set_data (bin, buffer, rsize);
 
-	return bin->binary_length;
+	return gda_binary_get_size (bin);
 }
 
 /*
@@ -268,18 +265,18 @@ gda_sqlite_blob_op_write (GdaBlobOp *op, GdaBlob *blob, glong offset)
 	if (len < 0)
 		return -1;
 
-	if (blob->op && (blob->op != op)) {
+	if (gda_blob_get_op (blob) && (gda_blob_get_op (blob) != op)) {
 		/* use data through blob->op */
 		#define buf_size 16384
 		gint nread = 0;
-		GdaBlob *tmpblob = g_new0 (GdaBlob, 1);
-		gda_blob_set_op (tmpblob, blob->op);
+		GdaBlob *tmpblob = gda_blob_new ();
+		gda_blob_set_op (tmpblob, gda_blob_get_op (blob));
 
 		nbwritten = 0;
 
-		for (nread = gda_blob_op_read (tmpblob->op, tmpblob, nbwritten, buf_size);
+		for (nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, nbwritten, buf_size);
 		     nread > 0;
-		     nread = gda_blob_op_read (tmpblob->op, tmpblob, nbwritten, buf_size)) {
+		     nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, nbwritten, buf_size)) {
 			int tmp_written;
 			int rc;
 			int wlen;
@@ -290,7 +287,7 @@ gda_sqlite_blob_op_write (GdaBlobOp *op, GdaBlob *blob, glong offset)
 				wlen = nread;
 
 			rc = SQLITE3_CALL (sqlite3_blob_write) (bop->priv->sblob,
-								((GdaBinary *)tmpblob)->data, wlen, offset + nbwritten);
+								gda_binary_get_data (gda_blob_get_binary (tmpblob)), wlen, offset + nbwritten);
 			if (rc != SQLITE_OK)
 				tmp_written = -1;
 			else
@@ -312,13 +309,13 @@ gda_sqlite_blob_op_write (GdaBlobOp *op, GdaBlob *blob, glong offset)
 		/* write blob using bin->data and bin->binary_length */
 		int rc;
 		int wlen;
-		bin = (GdaBinary *) blob;
-		if (bin->binary_length + offset > len)
+		bin = gda_blob_get_binary (blob);
+		if (gda_binary_get_size (bin) + offset > len)
 			wlen = 	len - offset;
 		else
-			wlen = bin->binary_length;
+			wlen = gda_binary_get_size (bin);
 
-		rc = SQLITE3_CALL (sqlite3_blob_write) (bop->priv->sblob, bin->data, wlen, offset);
+		rc = SQLITE3_CALL (sqlite3_blob_write) (bop->priv->sblob, gda_binary_get_data (bin), wlen, offset);
 		if (rc != SQLITE_OK)
 			nbwritten = -1;
 		else
diff --git a/libgda/sqlite/gda-sqlite-handler-bin.c b/libgda/sqlite/gda-sqlite-handler-bin.c
index 42e3e3a..d0282bb 100644
--- a/libgda/sqlite/gda-sqlite-handler-bin.c
+++ b/libgda/sqlite/gda-sqlite-handler-bin.c
@@ -165,13 +165,13 @@ gda_sqlite_handler_bin_get_sql_from_value (G_GNUC_UNUSED GdaDataHandler *iface,
 	gint i;
 
 	bin = (GdaBinary *) gda_value_get_binary ((GValue *) value);
-	retval = g_new0 (gchar, bin->binary_length * 2 + 4);
+	retval = g_new0 (gchar, gda_binary_get_size (bin) * 2 + 4);
 	retval [0] = 'x';
 	retval [1] = '\'';
-	for (i = 0; i < bin->binary_length; i++) {
+	for (i = 0; i < gda_binary_get_size (bin); i++) {
 		guchar *ptr;
 
-		ptr = bin->data + i;
+		ptr = gda_binary_get_data (bin) + i;
 		if ((*ptr >> 4) <= 9)
 			retval [2*i + 2] = (*ptr >> 4) + '0';
 		else
@@ -181,7 +181,7 @@ gda_sqlite_handler_bin_get_sql_from_value (G_GNUC_UNUSED GdaDataHandler *iface,
 		else
 			retval [2*i + 3] = (*ptr & 0xF) + 'A' - 10;
 	}
-	retval [bin->binary_length * 2 + 2] = '\'';
+	retval [gda_binary_get_size (bin) * 2 + 2] = '\'';
 
 	return retval;
 }
@@ -196,11 +196,11 @@ gda_sqlite_handler_bin_get_str_from_value (G_GNUC_UNUSED GdaDataHandler *iface,
 	gint i;
 
 	bin = (GdaBinary *) gda_value_get_binary ((GValue *) value);
-	retval = g_new0 (gchar, bin->binary_length * 2 + 1);
-	for (i = 0; i < bin->binary_length; i++) {
+	retval = g_new0 (gchar, gda_binary_get_size (bin) * 2 + 1);
+	for (i = 0; i < gda_binary_get_size (bin); i++) {
 		guchar *ptr;
 
-		ptr = bin->data + i;
+		ptr = gda_binary_get_data (bin) + i;
 		if ((*ptr >> 4) <= 9)
 			retval [2*i] = (*ptr >> 4) + '0';
 		else
@@ -242,13 +242,14 @@ gda_sqlite_handler_bin_get_value_from_sql (G_GNUC_UNUSED GdaDataHandler *iface,
 		    (sql[n] == '\'')) {
 			GdaBinary *bin;
 			
-			bin = g_new0 (GdaBinary, 1);
+			bin = gda_binary_new ();
 			if (n > 3) {
 				gint i;
-				bin->data = g_new0 (guchar, (n-3)/2);
+				guchar* buffer = g_new0 (guchar, (n-3)/2);
 				for (i = 2; i < n-1; i += 2)
-					bin->data [i/2 - 1] = (hex_to_int (sql[i]) << 4) | hex_to_int (sql [i+1]);
-				bin->binary_length = n-3;
+					buffer [i/2 - 1] = (hex_to_int (sql[i]) << 4) | hex_to_int (sql [i+1]);
+				gda_binary_set_data (bin, buffer, n-3);
+				g_free (buffer);
 			}
 
 			value = gda_value_new (GDA_TYPE_BINARY);
@@ -271,15 +272,15 @@ gda_sqlite_handler_bin_get_value_from_str (G_GNUC_UNUSED GdaDataHandler *iface,
 		if (! (n % 2)) {
 			GdaBinary *bin;
 
-			bin = g_new0 (GdaBinary, 1);
+			bin = gda_binary_new ();
+			guchar* buffer = NULL;
 			if (n > 0) {
 				gint i;
-				bin->data = g_new0 (guchar, n/2);
+				buffer = g_new0 (guchar, n/2);
 				for (i = 0; i < n; i += 2)
-					bin->data [i/2] = (hex_to_int (str[i]) << 4) | hex_to_int (str [i+1]);
-				bin->binary_length = n;
+					buffer [i/2] = (hex_to_int (str[i]) << 4) | hex_to_int (str [i+1]);
 			}
-
+      gda_binary_set_data (bin, buffer, n);
 			value = gda_value_new (GDA_TYPE_BINARY);
 			gda_value_take_binary (value, bin);
 		}
diff --git a/libgda/sqlite/gda-sqlite-provider.c b/libgda/sqlite/gda-sqlite-provider.c
index 931909d..a909cb8 100644
--- a/libgda/sqlite/gda-sqlite-provider.c
+++ b/libgda/sqlite/gda-sqlite-provider.c
@@ -3197,10 +3197,10 @@ gda_sqlite_provider_statement_execute (GdaServerProvider *provider, GdaConnectio
 			const gchar *str = NULL;
 
 			/* force reading the complete BLOB into memory */
-			if (blob->op)
-				blob_len = gda_blob_op_get_length (blob->op);
+			if (gda_blob_get_op (blob))
+				blob_len = gda_blob_op_get_length (gda_blob_get_op (blob));
 			else
-				blob_len = ((GdaBinary*) blob)->binary_length;
+				blob_len = gda_binary_get_size (gda_blob_get_binary (blob));
 			if (blob_len < 0)
 				str = _("Can't get BLOB's length");
 			else if (blob_len >= G_MAXINT)
@@ -3241,7 +3241,7 @@ gda_sqlite_provider_statement_execute (GdaServerProvider *provider, GdaConnectio
 		else if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
 			GdaBinary *bin = (GdaBinary *) gda_value_get_binary (value);
 			SQLITE3_CALL (sqlite3_bind_blob) (ps->sqlite_stmt, i,
-							  bin->data, bin->binary_length, SQLITE_TRANSIENT);
+							  gda_binary_get_data (bin), gda_binary_get_size (bin), SQLITE_TRANSIENT);
 		}
 		else if (G_VALUE_TYPE (value) == GDA_TYPE_TIME) {
 			GString *string;
@@ -3575,20 +3575,20 @@ scalar_gda_hex_print_func (sqlite3_context *context, int argc, sqlite3_value **a
 		return;
 	}
 
-	bin = g_new0 (GdaBinary, 1);
-	bin->data = (guchar*) SQLITE3_CALL (sqlite3_value_blob) (argv [0]);
-	if (!bin->data) {
-		g_free (bin);
+	bin = gda_binary_new ();
+	guchar* buffer = (guchar*) SQLITE3_CALL (sqlite3_value_blob) (argv [0]);
+	if (!buffer) {
+		gda_binary_free (bin);
 		SQLITE3_CALL (sqlite3_result_null) (context);
 		return;
 	}
-	bin->binary_length = SQLITE3_CALL (sqlite3_value_bytes) (argv [0]);
+	glong length = SQLITE3_CALL (sqlite3_value_bytes) (argv [0]);
+	gda_binary_set_data (bin, buffer, length);
+	g_free (free);
 	gda_value_take_binary ((value = gda_value_new (GDA_TYPE_BINARY)), bin);
 	dh = gda_data_handler_get_default (GDA_TYPE_BINARY);
 	str = gda_data_handler_get_str_from_value (dh, value);
 
-	bin->data = NULL;
-	bin->binary_length = 0;
 	gda_value_free (value);
 	SQLITE3_CALL (sqlite3_result_text) (context, str, -1, g_free);
 }
@@ -3607,20 +3607,19 @@ scalar_gda_hex_print_func2 (sqlite3_context *context, int argc, sqlite3_value **
 		return;
 	}
 
-	bin = g_new0 (GdaBinary, 1);
-	bin->data = (guchar*) SQLITE3_CALL (sqlite3_value_blob) (argv [0]);
-	if (!bin->data) {
-		g_free (bin);
+	bin = gda_binary_new ();
+	guchar* buffer = (guchar*) SQLITE3_CALL (sqlite3_value_blob) (argv [0]);
+	if (!buffer) {
+		gda_binary_free (bin);
 		SQLITE3_CALL (sqlite3_result_null) (context);
 		return;
 	}
-	bin->binary_length = SQLITE3_CALL (sqlite3_value_bytes) (argv [0]);
+	glong length = SQLITE3_CALL (sqlite3_value_bytes) (argv [0]);
+	gda_binary_set_data (bin, buffer, length);
 	gda_value_take_binary ((value = gda_value_new (GDA_TYPE_BINARY)), bin);
 	dh = gda_data_handler_get_default (GDA_TYPE_BINARY);
 	str = gda_data_handler_get_str_from_value (dh, value);
 
-	bin->data = NULL;
-	bin->binary_length = 0;
 	gda_value_free (value);
 
 	size = SQLITE3_CALL (sqlite3_value_int) (argv [1]);
diff --git a/libgda/sqlite/gda-sqlite-recordset.c b/libgda/sqlite/gda-sqlite-recordset.c
index 43518b4..677ecaf 100644
--- a/libgda/sqlite/gda-sqlite-recordset.c
+++ b/libgda/sqlite/gda-sqlite-recordset.c
@@ -351,6 +351,7 @@ fetch_next_sqlite_row (GdaSqliteRecordset *model, gboolean do_store, GError **er
 	GdaSqlitePStmt *ps;
 	GdaRow *prow = NULL;
 	GdaConnection *cnc;
+	glong length;
 
 	cnc = gda_data_select_get_connection ((GdaDataSelect*) model);
 	cdata = (SqliteConnectionData*) gda_connection_internal_get_provider_data_error (cnc, error);
@@ -466,16 +467,12 @@ fetch_next_sqlite_row (GdaSqliteRecordset *model, gboolean do_store, GError **er
 				else if (type == GDA_TYPE_BINARY) {
 					GdaBinary *bin;
 					
-					bin = g_new0 (GdaBinary, 1);
-					bin->binary_length = SQLITE3_CALL (sqlite3_column_bytes) (ps->sqlite_stmt, real_col);
-					if (bin->binary_length > 0) {
-						bin->data = g_new (guchar, bin->binary_length);
-						memcpy (bin->data, SQLITE3_CALL (sqlite3_column_blob) (ps->sqlite_stmt, /* Flawfinder: ignore */
-												       real_col),
-							bin->binary_length);
+					bin = gda_binary_new ();
+					length = SQLITE3_CALL (sqlite3_column_bytes) (ps->sqlite_stmt, real_col);
+					if (length > 0) {
+						gda_binary_set_data (bin, SQLITE3_CALL (sqlite3_column_blob) (ps->sqlite_stmt, /* Flawfinder: ignore */
+												       real_col), length);
 					}
-					else
-						bin->binary_length = 0;
 					gda_value_take_binary (value, bin);
 				}
 				else if (type == GDA_TYPE_BLOB) {
@@ -517,7 +514,7 @@ fetch_next_sqlite_row (GdaSqliteRecordset *model, gboolean do_store, GError **er
 					}
 					else {
 						GdaBlob *blob;
-						blob = g_new0 (GdaBlob, 1);
+						blob = gda_blob_new ();
 						gda_blob_set_op (blob, bop);
 						g_object_unref (bop);
 						gda_value_take_blob (value, blob);
diff --git a/libgda/sqlite/virtual/gda-vprovider-data-model.c b/libgda/sqlite/virtual/gda-vprovider-data-model.c
index 0393eaf..ad448f6 100644
--- a/libgda/sqlite/virtual/gda-vprovider-data-model.c
+++ b/libgda/sqlite/virtual/gda-vprovider-data-model.c
@@ -1042,15 +1042,17 @@ virtualColumn (sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i)
 		GdaBinary *bin;
 		blob = (GdaBlob *) gda_value_get_blob (value);
 		bin = (GdaBinary *) blob;
-		if (blob->op &&
-		    (bin->binary_length != gda_blob_op_get_length (blob->op)))
-			gda_blob_op_read_all (blob->op, blob);
-		SQLITE3_CALL (sqlite3_result_blob) (ctx, blob->data.data, blob->data.binary_length, SQLITE_TRANSIENT);
+		if (gda_blob_get_op (blob) &&
+		    (gda_binary_get_size (bin) != gda_blob_op_get_length (gda_blob_get_op(blob))))
+			gda_blob_op_read_all (gda_blob_get_op (blob), blob);
+		SQLITE3_CALL (sqlite3_result_blob) (ctx, gda_binary_get_data (gda_blob_get_binary (blob)),
+		                                    gda_binary_get_size (gda_blob_get_binary (blob)),
+		                                    SQLITE_TRANSIENT);
 	}
 	else if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
 		const GdaBinary *bin;
 		bin = gda_value_get_binary (value);
-		SQLITE3_CALL (sqlite3_result_blob) (ctx, bin->data, bin->binary_length, SQLITE_TRANSIENT);
+		SQLITE3_CALL (sqlite3_result_blob) (ctx, gda_binary_get_data (bin), gda_binary_get_size (bin), SQLITE_TRANSIENT);
 	}
 	else {
 		gchar *str = gda_value_stringify (value);
@@ -1091,15 +1093,12 @@ create_value_from_sqlite3_value_notype (sqlite3_value *svalue)
 	case SQLITE_BLOB: {
 		GdaBinary *bin;
 		g_value_init (value, GDA_TYPE_BINARY);
-		bin = g_new0 (GdaBinary, 1);
-		bin->binary_length = SQLITE3_CALL (sqlite3_value_bytes) (svalue);
-		if (bin->binary_length > 0) {
-			bin->data = g_new (guchar, bin->binary_length);
-			memcpy (bin->data, SQLITE3_CALL (sqlite3_value_blob) (svalue),
-				bin->binary_length);
+		bin = gda_binary_new ();
+		glong length = SQLITE3_CALL (sqlite3_value_bytes) (svalue);
+		if (length > 0) {
+			gpointer data = g_new (guchar, length);
+			gda_binary_set_data (bin, SQLITE3_CALL (sqlite3_value_blob) (svalue), length);
 		}
-		else
-			bin->binary_length = 0;
 		gda_value_take_binary (value, bin);
 		break;
 	}
diff --git a/providers/postgres/gda-postgres-blob-op.c b/providers/postgres/gda-postgres-blob-op.c
index ef2c070..ede0b74 100644
--- a/providers/postgres/gda-postgres-blob-op.c
+++ b/providers/postgres/gda-postgres-blob-op.c
@@ -334,17 +334,17 @@ gda_postgres_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong siz
 		goto out_error;
 	}
 
-	bin = (GdaBinary *) blob;
-	if (bin->data) 
-		g_free (bin->data);
-	bin->data = g_new0 (guchar, size);
-	bin->binary_length = lo_read (pconn, pgop->priv->fd, (char *) (bin->data), size);
+	bin = gda_blob_get_binary (blob);
+	gda_binary_reset_data (bin);
+	guchar *buffer = g_new0 (guchar, size);
+	glong l = lo_read (pconn, pgop->priv->fd, (char *) (buffer), size);
+	gda_binary_set_data (bin, buffer, l);
 
 	blob_op_close (pgop);
 	if (transaction_started)
 		gda_connection_rollback_transaction (pgop->priv->cnc, NULL, NULL);
 
-	return bin->binary_length;
+	return gda_binary_get_size (bin);
 
  out_error:
 	blob_op_close (pgop);
@@ -380,25 +380,25 @@ gda_postgres_blob_op_write (GdaBlobOp *op, GdaBlob *blob, glong offset)
 		goto out_error;
 	}
 
-	if (blob->op && (blob->op != op)) {
+	if (gda_blob_get_op (blob) && (gda_blob_get_op (blob) != op)) {
 		/* use data through blob->op */
 		#define buf_size 16384
 		gint nread = 0;
-		GdaBlob *tmpblob = g_new0 (GdaBlob, 1);
-		gda_blob_set_op (tmpblob, blob->op);
+		GdaBlob *tmpblob = gda_blob_new ();
+		gda_blob_set_op (tmpblob, gda_blob_get_op (blob));
 
 		nbwritten = 0;
 
-		for (nread = gda_blob_op_read (tmpblob->op, tmpblob, 0, buf_size);
+		for (nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, 0, buf_size);
 		     nread > 0;
-		     nread = gda_blob_op_read (tmpblob->op, tmpblob, nbwritten, buf_size)) {
-			GdaBinary *bin = (GdaBinary *) tmpblob;
+		     nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, nbwritten, buf_size)) {
+			GdaBinary *bin = gda_blob_get_binary (tmpblob);
 			glong tmp_written;
-			tmp_written = lo_write (pconn, pgop->priv->fd, (char*) bin->data, 
-						bin->binary_length);
-			if (tmp_written < bin->binary_length) {
+			tmp_written = lo_write (pconn, pgop->priv->fd, (char*) gda_binary_get_data (bin), 
+						gda_binary_get_size (bin));
+			if (tmp_written < gda_binary_get_size (bin)) {
 				_gda_postgres_make_error (pgop->priv->cnc, pconn, NULL, NULL);
-				gda_blob_free ((gpointer) tmpblob);
+				gda_blob_free (tmpblob);
 				goto out_error;
 			}
 			nbwritten += tmp_written;
@@ -406,12 +406,12 @@ gda_postgres_blob_op_write (GdaBlobOp *op, GdaBlob *blob, glong offset)
 				/* nothing more to read */
 				break;
 		}
-		gda_blob_free ((gpointer) tmpblob);
+		gda_blob_free (tmpblob);
 	}
 	else {
 		/* use data in (GdaBinary *) blob */
-		GdaBinary *bin = (GdaBinary *) blob;
-		nbwritten = lo_write (pconn, pgop->priv->fd, (char*) bin->data, bin->binary_length);
+		GdaBinary *bin = gda_blob_get_binary (blob);
+		nbwritten = lo_write (pconn, pgop->priv->fd, (char*) gda_binary_get_data (bin), gda_binary_get_size (bin));
 		if (nbwritten == -1) {
 			_gda_postgres_make_error (pgop->priv->cnc, pconn, NULL, NULL);
 			goto out_error;
diff --git a/providers/postgres/gda-postgres-handler-bin.c b/providers/postgres/gda-postgres-handler-bin.c
index 4daf9d6..44a3f0e 100644
--- a/providers/postgres/gda-postgres-handler-bin.c
+++ b/providers/postgres/gda-postgres-handler-bin.c
@@ -194,8 +194,8 @@ gda_postgres_handler_bin_get_sql_from_value (GdaDataHandler *iface, const GValue
 			/*tmp = PQescapeByteaConn (cdata->pconn, data, length, &retlength);*/
 		}
 		else
-			tmp = (gchar *) PQescapeBytea (data->data, 
-						       data->binary_length, &retlength);
+			tmp = (gchar *) PQescapeBytea (gda_binary_get_data (data), 
+						       gda_binary_get_size (data), &retlength);
 		if (tmp) {
 			retval = g_strdup_printf ("'%s'", tmp);
 			PQfreemem (tmp);
diff --git a/providers/postgres/gda-postgres-provider.c b/providers/postgres/gda-postgres-provider.c
index fde3d04..154f86b 100644
--- a/providers/postgres/gda-postgres-provider.c
+++ b/providers/postgres/gda-postgres-provider.c
@@ -2208,8 +2208,8 @@ gda_postgres_provider_statement_execute (GdaServerProvider *provider, GdaConnect
 		else if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
 			/* directly bin binary data */
 			GdaBinary *bin = (GdaBinary *) gda_value_get_binary ((GValue *) value);
-			param_values [i] = (gchar*) bin->data;
-			param_lengths [i] = bin->binary_length;
+			param_values [i] = (gchar*) gda_binary_get_data (bin);
+			param_lengths [i] = gda_binary_get_size (bin);
 			param_formats [i] = 1; /* binary format */
 			param_mem [i] = TRUE; /* don't free later */
 		}
diff --git a/providers/postgres/gda-postgres-recordset.c b/providers/postgres/gda-postgres-recordset.c
index 2d95007..43687ca 100644
--- a/providers/postgres/gda-postgres-recordset.c
+++ b/providers/postgres/gda-postgres-recordset.c
@@ -737,9 +737,8 @@ set_value (GdaConnection *cnc, GdaRow *row, GValue *value, GType type, const gch
 					}
 					if (! *ptr) {
 						GdaBinary *bin;
-						bin = g_new (GdaBinary, 1);
-						bin->data = unescaped;
-						bin->binary_length = pqlength;
+						bin = gda_binary_new ();
+						gda_binary_set_data (bin, unescaped, pqlength);
 						gda_value_take_binary (value, bin);
 						valueset = TRUE;
 					}
@@ -748,10 +747,9 @@ set_value (GdaConnection *cnc, GdaRow *row, GValue *value, GType type, const gch
 			else {
 				unescaped = PQunescapeBytea ((guchar*) thevalue, &pqlength);
 				if (unescaped) {
-					GdaBinary bin;
-					bin.data = unescaped;
-					bin.binary_length = pqlength;
-					gda_value_set_binary (value, &bin);
+					GdaBinary* bin = gda_binary_new ();
+					gda_binary_set_data (bin, unescaped, pqlength);
+					gda_value_take_binary (value, bin);
 					PQfreemem (unescaped);
 					valueset = TRUE;
 				}
@@ -771,7 +769,7 @@ set_value (GdaConnection *cnc, GdaRow *row, GValue *value, GType type, const gch
 	else if (type == GDA_TYPE_BLOB) {
 		GdaBlob *blob;
 		GdaBlobOp *op;
-		blob = g_new0 (GdaBlob, 1);
+		blob = gda_blob_new ();
 		op = gda_postgres_blob_op_new_with_id (cnc, thevalue);
 		gda_blob_set_op (blob, op);
 		g_object_unref (op);
diff --git a/providers/skel-implementation/capi/gda-capi-blob-op.c b/providers/skel-implementation/capi/gda-capi-blob-op.c
index fc72351..ef37acf 100644
--- a/providers/skel-implementation/capi/gda-capi-blob-op.c
+++ b/providers/skel-implementation/capi/gda-capi-blob-op.c
@@ -164,16 +164,18 @@ gda_capi_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size)
 		return -1;
 	g_return_val_if_fail (blob, -1);
 
-	bin = (GdaBinary *) blob;
-	if (bin->data) 
-		g_free (bin->data);
-	bin->data = g_new0 (guchar, size);
-	bin->binary_length = 0;
+	bin = gda_blob_get_binary (blob);
+	if (gda_binary_get_data (bin))
+	  gda_binary_reset_data (bin); 
+		g_free (gda_binary_get_data (bin));
+	guchar* buffer = g_new0 (guchar, size);
+	gda_binary_set_data (bin, buffer, size);
+	g_free (buffer);
 
 	/* fetch blob data using C API into bin->data, and set bin->binary_length */
 	TO_IMPLEMENT;
 
-	return bin->binary_length;
+	return gda_binary_get_size (bin);
 }
 
 /*
@@ -192,25 +194,25 @@ gda_capi_blob_op_write (GdaBlobOp *op, GdaBlob *blob, G_GNUC_UNUSED glong offset
 	g_return_val_if_fail (GDA_IS_CONNECTION (bop->priv->cnc), -1);
 	g_return_val_if_fail (blob, -1);
 
-	if (blob->op && (blob->op != op)) {
+	if (gda_blob_get_op (blob) && (gda_blob_get_op (blob) != op)) {
 		/* use data through blob->op */
 		#define buf_size 16384
 		gint nread = 0;
-		GdaBlob *tmpblob = g_new0 (GdaBlob, 1);
-		gda_blob_set_op (tmpblob, blob->op);
+		GdaBlob *tmpblob = gda_blob_new ();
+		gda_blob_set_op (tmpblob, gda_blob_get_op (blob));
 
 		nbwritten = 0;
 
-		for (nread = gda_blob_op_read (tmpblob->op, tmpblob, nbwritten, buf_size);
+		for (nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, nbwritten, buf_size);
 		     nread > 0;
-		     nread = gda_blob_op_read (tmpblob->op, tmpblob, nbwritten, buf_size)) {
+		     nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, nbwritten, buf_size)) {
 			glong tmp_written;
 
 			tmp_written = -1; TO_IMPLEMENT;
 			
 			if (tmp_written < 0) {
 				/* treat error */
-				gda_blob_free ((gpointer) tmpblob);
+				gda_blob_free (tmpblob);
 				return -1;
 			}
 			nbwritten += tmp_written;
@@ -218,12 +220,12 @@ gda_capi_blob_op_write (GdaBlobOp *op, GdaBlob *blob, G_GNUC_UNUSED glong offset
 				/* nothing more to read */
 				break;
 		}
-		gda_blob_free ((gpointer) tmpblob);
+		gda_blob_free (tmpblob);
 	}
 	else {
 		/* write blob using bin->data and bin->binary_length */
-		bin = (GdaBinary *) blob;
-    		g_warning("bin not used. length=%ld", bin->binary_length); /* Avoids a compiler warning. */        
+		bin = gda_blob_get_binary (blob);
+    		g_warning("bin not used. length=%ld", gda_binary_get_size (bin)); /* Avoids a compiler warning. */        
 		nbwritten = -1; TO_IMPLEMENT;
 	}
 
diff --git a/providers/web/gda-web-blob-op.c b/providers/web/gda-web-blob-op.c
index d98ccab..d79c143 100644
--- a/providers/web/gda-web-blob-op.c
+++ b/providers/web/gda-web-blob-op.c
@@ -162,16 +162,15 @@ gda_web_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size)
 		return -1;
 	g_return_val_if_fail (blob, -1);
 
-	bin = (GdaBinary *) blob;
-	if (bin->data) 
-		g_free (bin->data);
-	bin->data = g_new0 (guchar, size);
-	bin->binary_length = 0;
+	bin = gda_blob_get_binary (blob);
+	gda_binary_reset_data (bin);
+	guchar *buffer = g_new0 (guchar, size);
+	gda_binary_set_data (bin, buffer, 0);
 
 	/* fetch blob data using C API into bin->data, and set bin->binary_length */
 	TO_IMPLEMENT;
 
-	return bin->binary_length;
+	return gda_binary_get_size (bin);
 }
 
 /*
@@ -190,25 +189,25 @@ gda_web_blob_op_write (GdaBlobOp *op, GdaBlob *blob, G_GNUC_UNUSED glong offset)
 	g_return_val_if_fail (GDA_IS_CONNECTION (bop->priv->cnc), -1);
 	g_return_val_if_fail (blob, -1);
 
-	if (blob->op && (blob->op != op)) {
+	if (gda_blob_get_op (blob) && (gda_blob_get_op (blob) != op)) {
 		/* use data through blob->op */
 		#define buf_size 16384
 		gint nread = 0;
-		GdaBlob *tmpblob = g_new0 (GdaBlob, 1);
-		gda_blob_set_op (tmpblob, blob->op);
+		GdaBlob *tmpblob = gda_blob_new ();
+		gda_blob_set_op (tmpblob, gda_blob_get_op (blob));
 
 		nbwritten = 0;
 
-		for (nread = gda_blob_op_read (tmpblob->op, tmpblob, nbwritten, buf_size);
+		for (nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, nbwritten, buf_size);
 		     nread > 0;
-		     nread = gda_blob_op_read (tmpblob->op, tmpblob, nbwritten, buf_size)) {
+		     nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, nbwritten, buf_size)) {
 			glong tmp_written;
 
 			tmp_written = -1; TO_IMPLEMENT;
 			
 			if (tmp_written < 0) {
 				/* treat error */
-				gda_blob_free ((gpointer) tmpblob);
+				gda_blob_free (tmpblob);
 				return -1;
 			}
 			nbwritten += tmp_written;
@@ -216,12 +215,12 @@ gda_web_blob_op_write (GdaBlobOp *op, GdaBlob *blob, G_GNUC_UNUSED glong offset)
 				/* nothing more to read */
 				break;
 		}
-		gda_blob_free ((gpointer) tmpblob);
+		gda_blob_free (tmpblob);
 	}
 	else {
 		/* write blob using bin->data and bin->binary_length */
-		bin = (GdaBinary *) blob;
-		g_warning("bin not used. length=%ld", bin->binary_length); /* Avoids a compiler warning. */   
+		bin = gda_blob_get_binary (blob);
+		g_warning("bin not used. length=%ld", gda_binary_get_size (bin)); /* Avoids a compiler warning. */   
 		nbwritten = -1; TO_IMPLEMENT;
 	}
 
diff --git a/testing/gdaui-test-data-entries.c b/testing/gdaui-test-data-entries.c
index 0724b20..e7ac06d 100644
--- a/testing/gdaui-test-data-entries.c
+++ b/testing/gdaui-test-data-entries.c
@@ -924,12 +924,12 @@ entry_contents_or_attrs_changed (GtkWidget *entry, G_GNUC_UNUSED gpointer data)
 		if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
 			const GdaBinary *bin;
 			bin = gda_value_get_binary (value);
-			strval = g_strdup_printf ("Binary data, size=%ld", bin->binary_length);
+			strval = g_strdup_printf ("Binary data, size=%ld", gda_binary_get_size (bin));
 		}
 		else if (G_VALUE_TYPE (value) == GDA_TYPE_BLOB) {
 			const GdaBlob *blob;
 			blob = gda_value_get_blob (value);
-			strval = g_strdup_printf ("Blob data, size=%ld", ((GdaBinary*) blob)->binary_length);
+			strval = g_strdup_printf ("Blob data, size=%ld", gda_binary_get_size (gda_blob_get_binary (blob)));
 		}
 		else
 			strval = gda_data_handler_get_sql_from_value (dh, value);
diff --git a/tools/common/t-app.c b/tools/common/t-app.c
index cc147df..6797d35 100644
--- a/tools/common/t-app.c
+++ b/tools/common/t-app.c
@@ -4539,7 +4539,7 @@ extra_command_export (ToolCommand *command, guint argc, const gchar **argv,
 			GValue *vblob = gda_value_new_blob_from_file (filename);
 			GdaBlob *tblob = (GdaBlob*) gda_value_get_blob (vblob);
 			const GdaBlob *fblob = gda_value_get_blob (value);
-			if (gda_blob_op_write (tblob->op, (GdaBlob*) fblob, 0) < 0)
+			if (gda_blob_op_write (gda_blob_get_op (tblob), (GdaBlob*) fblob, 0) < 0)
 				g_set_error (error, T_ERROR, T_INTERNAL_COMMAND_ERROR,
 					     "%s", _("Could not write file"));
 			else
@@ -4549,16 +4549,17 @@ extra_command_export (ToolCommand *command, guint argc, const gchar **argv,
 		else if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
 			GValue *vblob = gda_value_new_blob_from_file (filename);
 			GdaBlob *tblob = (GdaBlob*) gda_value_get_blob (vblob);
-			GdaBlob *fblob = g_new0 (GdaBlob, 1);
+			GdaBlob *fblob = gda_blob_new ();
 			const GdaBinary *fbin = gda_value_get_binary (value);
-			((GdaBinary *) fblob)->data = fbin->data;
-			((GdaBinary *) fblob)->binary_length = fbin->binary_length;
-			if (gda_blob_op_write (tblob->op, (GdaBlob*) fblob, 0) < 0)
+			gda_binary_set_data (gda_blob_get_binary (fblob),
+			                    gda_binary_get_data (fbin),
+			                    gda_binary_get_size (fbin));
+			if (gda_blob_op_write (gda_blob_get_op (tblob), (GdaBlob*) fblob, 0) < 0)
 				g_set_error (error, T_ERROR, T_INTERNAL_COMMAND_ERROR,
 					     "%s", _("Could not write file"));
 			else
 				done = TRUE;
-			g_free (fblob);
+			gda_blob_free (fblob);
 			gda_value_free (vblob);
 		}
 		else {