diff --git a/libgda-ui/data-entries/common-bin.c b/libgda-ui/data-entries/common-bin.c
index 4a9cb83..9b7d719 100644
--- a/libgda-ui/data-entries/common-bin.c
+++ b/libgda-ui/data-entries/common-bin.c
@@ -262,7 +262,7 @@ common_bin_adjust_menu (BinMenu *binmenu, gboolean editable, const GValue *value
 	string = g_string_new ("");
 	if (value) {
 		binmenu->tmpvalue = gda_value_copy (value);
-		if (G_VALUE_TYPE (value) == GDA_TYPE_NULL)
+		if (G_VALUE_TYPE (value) == G_TYPE_INVALID)
 			g_string_append_printf (string, "<i>%s</i>", _("No data"));
 		else if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
 			const GdaBinary *bin;
diff --git a/libgda-ui/data-entries/gdaui-data-cell-renderer-bin.c b/libgda-ui/data-entries/gdaui-data-cell-renderer-bin.c
index 39be074..92bafe9 100644
--- a/libgda-ui/data-entries/gdaui-data-cell-renderer-bin.c
+++ b/libgda-ui/data-entries/gdaui-data-cell-renderer-bin.c
@@ -274,7 +274,7 @@ gdaui_data_cell_renderer_bin_set_property (GObject *object,
 		/* Because we don't have a copy of the value, we MUST NOT free it! */
 		if (value) {	
                         GValue *gval = g_value_get_boxed (value);
-			if (gval && (G_VALUE_TYPE (gval) != GDA_TYPE_NULL))
+			if (gval && (G_VALUE_TYPE (gval) != G_TYPE_INVALID))
 				g_object_set (object, "pixbuf", attach_pixbuf, NULL);
 			else if (gval)
 				g_object_set (object, "pixbuf", NULL, NULL);
diff --git a/libgda-ui/data-entries/gdaui-entry-bin.c b/libgda-ui/data-entries/gdaui-entry-bin.c
index e560981..583b732 100644
--- a/libgda-ui/data-entries/gdaui-entry-bin.c
+++ b/libgda-ui/data-entries/gdaui-entry-bin.c
@@ -134,7 +134,7 @@ show (GtkWidget *widget)
 
 	dbin = GDAUI_ENTRY_BIN (widget);
 	value = dbin->priv->current_data;
-	if (value && (G_VALUE_TYPE (value) != GDA_TYPE_NULL)) {
+	if (value && (G_VALUE_TYPE (value) != G_TYPE_INVALID)) {
 		gtk_widget_show (dbin->priv->button_image);
 		gtk_widget_hide (dbin->priv->button_label);
 	}
@@ -272,7 +272,7 @@ take_current_value (GdauiEntryBin *dbin, GValue *value)
 
 	/* new situation */
 	dbin->priv->current_data = value;
-	if (value && (G_VALUE_TYPE (value) != GDA_TYPE_NULL)) {
+	if (value && (G_VALUE_TYPE (value) != G_TYPE_INVALID)) {
 		gtk_widget_show (dbin->priv->button_image);
 		gtk_widget_hide (dbin->priv->button_label);
 	}
diff --git a/libgda-ui/data-entries/gdaui-entry-combo.c b/libgda-ui/data-entries/gdaui-entry-combo.c
index 5d9b69a..1b5d005 100644
--- a/libgda-ui/data-entries/gdaui-entry-combo.c
+++ b/libgda-ui/data-entries/gdaui-entry-combo.c
@@ -484,7 +484,7 @@ gdaui_entry_combo_set_values (GdauiEntryCombo *combo, GSList *values)
 
 	/* try to determine if all the values are NULL or of type GDA_TYPE_NULL */
 	for (list = values; list; list = list->next) {
-		if (list->data && (G_VALUE_TYPE ((GValue *)list->data) != GDA_TYPE_NULL)) {
+		if (list->data && (G_VALUE_TYPE ((GValue *)list->data) != G_TYPE_INVALID)) {
 			allnull = FALSE;
 			break;
 		}
@@ -635,7 +635,7 @@ gdaui_entry_combo_set_reference_values (GdauiEntryCombo *combo, GSList *values)
 		     argptr && nodes && equal;
 		     nodes = nodes->next, argptr = argptr->next) {
 			GdaColumn *attrs;
-			GType type = GDA_TYPE_NULL;
+			GType type = G_TYPE_INVALID;
 			
 			attrs = gda_data_model_describe_column (combo->priv->source->source->data_model, 
 								COMBO_NODE (nodes->data)->node->source_column);
diff --git a/libgda-ui/gdaui-basic-form.c b/libgda-ui/gdaui-basic-form.c
index 1382a07..38c4b04 100644
--- a/libgda-ui/gdaui-basic-form.c
+++ b/libgda-ui/gdaui-basic-form.c
@@ -964,7 +964,7 @@ create_entry_widget (SingleEntry *sentry)
 		}
 		else if (!nnul ||
 			 (nnul && value &&
-			  (G_VALUE_TYPE ((GValue *) value) != GDA_TYPE_NULL)))
+			  (G_VALUE_TYPE ((GValue *) value) != G_TYPE_INVALID)))
 			gdaui_data_entry_set_reference_value (GDAUI_DATA_ENTRY (entry), value);
 
 		if (default_val) {
diff --git a/libgda-ui/gdaui-combo.c b/libgda-ui/gdaui-combo.c
index 96adc12..422312a 100644
--- a/libgda-ui/gdaui-combo.c
+++ b/libgda-ui/gdaui-combo.c
@@ -436,7 +436,7 @@ gdaui_combo_set_model (GdauiCombo *combo, GdaDataModel *model, gint n_cols, gint
 		for (j = 0; j < nrows; j++) {
 			for (i = 0; i < ln_cols; i++) {
 				cvalue = gda_data_model_get_value_at (model, combo->priv->cols_index [i], j, NULL);
-				if (cvalue && (G_VALUE_TYPE (cvalue) != GDA_TYPE_NULL)) {
+				if (cvalue && (G_VALUE_TYPE (cvalue) != G_TYPE_INVALID)) {
 					gchar *str;
 					gint len;
 					dh = gda_data_handler_get_default (G_VALUE_TYPE (cvalue));
@@ -800,7 +800,7 @@ combo_selector_set_column_visible (GdauiDataSelector *iface, gint column, gboole
 		nrows = gda_data_model_get_n_rows (combo->priv->model);
 		for (j = 0; j < nrows; j++) {
 			cvalue = gda_data_model_get_value_at (combo->priv->model, column, j, NULL);
-			if (cvalue && (G_VALUE_TYPE (cvalue) != GDA_TYPE_NULL)) {
+			if (cvalue && (G_VALUE_TYPE (cvalue) != G_TYPE_INVALID)) {
 				gchar *str;
 				gint len;
 				dh = gda_data_handler_get_default (G_VALUE_TYPE (cvalue));
diff --git a/libgda/gda-column.c b/libgda/gda-column.c
index 671a0be..f47d111 100644
--- a/libgda/gda-column.c
+++ b/libgda/gda-column.c
@@ -429,7 +429,7 @@ gda_column_set_dbms_type (GdaColumn *column, const gchar *dbms_type)
 GType
 gda_column_get_g_type (GdaColumn *column)
 {
-	g_return_val_if_fail (GDA_IS_COLUMN (column), GDA_TYPE_NULL);
+	g_return_val_if_fail (GDA_IS_COLUMN (column), G_TYPE_INVALID);
 	return column->priv->g_type;
 }
 
diff --git a/libgda/gda-connection.c b/libgda/gda-connection.c
index 0ea62a1..7720db3 100644
--- a/libgda/gda-connection.c
+++ b/libgda/gda-connection.c
@@ -1865,7 +1865,7 @@ gda_connection_insert_row_into_table_v (GdaConnection *cnc, const gchar *table,
 
 		/* value */
 		expr = gda_sql_expr_new (GDA_SQL_ANY_PART (ssi));
-		if (value && (G_VALUE_TYPE (value) != GDA_TYPE_NULL)) {
+		if (value && (G_VALUE_TYPE (value) != G_TYPE_INVALID)) {
 			/* create a GdaSqlExpr with a parameter */
 			GdaSqlParamSpec *param;
 			param = g_new0 (GdaSqlParamSpec, 1);
@@ -2074,7 +2074,7 @@ gda_connection_update_row_in_table_v (GdaConnection *cnc, const gchar *table,
 
 		/* value */
 		expr = gda_sql_expr_new (GDA_SQL_ANY_PART (ssu));
-		if (value && (G_VALUE_TYPE (value) != GDA_TYPE_NULL)) {
+		if (value && (G_VALUE_TYPE (value) != G_TYPE_INVALID)) {
 			/* create a GdaSqlExpr with a parameter */
 			GdaSqlParamSpec *param;
 			param = g_new0 (GdaSqlParamSpec, 1);
@@ -3263,7 +3263,7 @@ gda_connection_execute_non_select_command (GdaConnection *cnc, const gchar *sql,
  * Note3: If @stmt is a SELECT statement which has some parameters and  if @params is not %NULL but contains some
  * invalid parameters and if @model_usage has the GDA_STATEMENT_MODEL_ALLOW_NOPARAM flag, then the returned
  * data model will contain no row but will have all the correct columns (even though some of the columns might
- * report as GDA_TYPE_NULL). In this case, if (after this method call) any of @params' parameters change
+ * report as G_TYPE_INVALID). In this case, if (after this method call) any of @params' parameters change
  * then the resulting data model will re-run itself, see the GdaDataSelect's 
  * <link linkend="GdaDataSelect--auto-reset">auto-reset</link> property for more information.
  *
diff --git a/libgda/gda-data-handler.c b/libgda/gda-data-handler.c
index 621c539..17d1b8a 100644
--- a/libgda/gda-data-handler.c
+++ b/libgda/gda-data-handler.c
@@ -82,7 +82,7 @@ gda_data_handler_iface_init (G_GNUC_UNUSED gpointer g_class)
  * to use variables in statements instead of value literals, see
  * the <link linkend="GdaSqlParser.description">GdaSqlParser</link> for more information.
  *
- * If the value is NULL or is of type GDA_TYPE_NULL,
+ * If the value is NULL or is of type G_TYPE_INVALID or GDA_TYPE_NULL,
  * or is a G_TYPE_STRING and g_value_get_string() returns %NULL, the returned string is "NULL".
  *
  * Returns: (transfer full): the new string, or %NULL if an error occurred
@@ -92,7 +92,7 @@ gda_data_handler_get_sql_from_value (GdaDataHandler *dh, const GValue *value)
 {
 	g_return_val_if_fail (dh && GDA_IS_DATA_HANDLER (dh), NULL);
 	
-	if (! value || gda_value_is_null (value))
+	if (! value || !G_IS_VALUE (value) || gda_value_is_null (value))
 		return g_strdup ("NULL");
 
 	/* Calling the real function with value != NULL and not of type GDA_TYPE_NULL */
@@ -109,7 +109,7 @@ gda_data_handler_get_sql_from_value (GdaDataHandler *dh, const GValue *value)
  *
  * Creates a new string which is a "user friendly" representation of the given value
  * (in the user's locale, specially for the dates). If the value is 
- * NULL or is of type GDA_TYPE_NULL, the returned string is a copy of "" (empty string).
+ * NULL or is of type G_TYPE_INVALID or GDA_TYPE_NULL, the returned string is a copy of "" (empty string).
  *
  * Returns: (transfer full): the new string, or %NULL if an error occurred
  */
@@ -118,7 +118,7 @@ gda_data_handler_get_str_from_value (GdaDataHandler *dh, const GValue *value)
 {
 	g_return_val_if_fail (dh && GDA_IS_DATA_HANDLER (dh), NULL);
 
-	if (! value || gda_value_is_null (value))
+	if (! value || !G_IS_VALUE (value) || gda_value_is_null (value))
 		return g_strdup ("");
 
 	/* Calling the real function with value != NULL and not of type GDA_TYPE_NULL */
diff --git a/libgda/gda-data-meta-wrapper.c b/libgda/gda-data-meta-wrapper.c
index aba4810..b4d32d5 100644
--- a/libgda/gda-data-meta-wrapper.c
+++ b/libgda/gda-data-meta-wrapper.c
@@ -634,4 +634,3 @@ gda_data_meta_wrapper_get_value_at (GdaDataModel *model, gint col, gint row, GEr
 	}
 	return NULL;
 }
-
diff --git a/libgda/gda-data-model-array.c b/libgda/gda-data-model-array.c
index 4cc00ea..9b781ce 100644
--- a/libgda/gda-data-model-array.c
+++ b/libgda/gda-data-model-array.c
@@ -500,7 +500,7 @@ column_g_type_changed_cb (GdaColumn *column, G_GNUC_UNUSED GType old, GType new,
 			continue;
 
 		vtype = G_VALUE_TYPE ((GValue *) value);
-                if ((vtype != GDA_TYPE_NULL) && (vtype != new)) {
+                if ((vtype != G_TYPE_INVALID) && (vtype != new)) {
                         nb_warnings ++;
                         if (nb_warnings < max_warnings) {
                                 if (nb_warnings == max_warnings)
diff --git a/libgda/gda-data-model-iter.c b/libgda/gda-data-model-iter.c
index 9c420bc..4cd4996 100644
--- a/libgda/gda-data-model-iter.c
+++ b/libgda/gda-data-model-iter.c
@@ -248,17 +248,17 @@ model_reset_cb (GdaDataModel *model, GdaDataModelIter *iter)
 	gda_data_model_iter_invalidate_contents (iter);
 	gda_data_model_iter_move_to_row (iter, -1);
 	
-	/* adjust GdaHolder's type if a column's type has changed from GDA_TYPE_NULL
+	/* adjust GdaHolder's type if a column's type has changed from G_TYPE_INVALID
 	 * to something else */
 	gint i;
 	GSList *list;
 	for (i = 0, list = ((GdaSet*) iter)->holders;
 	     list;
 	     i++, list = list->next) {
-		if (gda_holder_get_g_type ((GdaHolder *) list->data) == GDA_TYPE_NULL) {
+		if (gda_holder_get_g_type ((GdaHolder *) list->data) == G_TYPE_INVALID) {
 			GdaColumn *col;
 			col = gda_data_model_describe_column (model, i);
-			if (gda_column_get_g_type (col) != GDA_TYPE_NULL)
+			if (gda_column_get_g_type (col) != G_TYPE_INVALID)
 				g_object_set (G_OBJECT (list->data), "g-type",
 					      gda_column_get_g_type (col), NULL);
 		}
diff --git a/libgda/gda-data-model.c b/libgda/gda-data-model.c
index a4a8731..372118d 100644
--- a/libgda/gda-data-model.c
+++ b/libgda/gda-data-model.c
@@ -658,7 +658,7 @@ gda_data_model_get_typed_value_at (GdaDataModel *model, gint col, gint row, GTyp
 
 	if (cvalue) {
 		if (nullok && 
-		    (G_VALUE_TYPE (cvalue) != GDA_TYPE_NULL) && 
+		    (G_VALUE_TYPE (cvalue) != G_TYPE_INVALID) && 
 		    (G_VALUE_TYPE (cvalue) != expected_type)) {
 			g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_VALUE_TYPE_ERROR,
 				     _("Data model returned value of invalid '%s' type"), 
@@ -666,7 +666,7 @@ gda_data_model_get_typed_value_at (GdaDataModel *model, gint col, gint row, GTyp
 			cvalue = NULL;
 		}
 		else if (!nullok && (G_VALUE_TYPE (cvalue) != expected_type)) {
-			if (G_VALUE_TYPE (cvalue) == GDA_TYPE_NULL)
+			if (G_VALUE_TYPE (cvalue) == G_TYPE_INVALID)
 				g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_VALUE_TYPE_ERROR,
 					      "%s", _("Data model returned invalid NULL value"));
 			else
diff --git a/libgda/gda-data-proxy.c b/libgda/gda-data-proxy.c
index b22df1d..7580adc 100644
--- a/libgda/gda-data-proxy.c
+++ b/libgda/gda-data-proxy.c
@@ -3711,8 +3711,8 @@ gda_data_proxy_set_value_at (GdaDataModel *model, gint col, gint proxy_row, cons
 			gda_mutex_unlock (proxy->priv->mutex);
 			return FALSE;
 		}
-		if ((G_VALUE_TYPE (cmp_value) != GDA_TYPE_NULL) &&
-		    (G_VALUE_TYPE (value) != GDA_TYPE_NULL) &&
+		if ((G_VALUE_TYPE (cmp_value) != G_TYPE_INVALID) &&
+		    (G_VALUE_TYPE (value) != G_TYPE_INVALID) &&
 		    (G_VALUE_TYPE (value) != G_VALUE_TYPE (cmp_value))) {
 			gda_mutex_unlock (proxy->priv->mutex);
 			g_warning (_("Wrong value type: expected '%s' and got '%s'"),
diff --git a/libgda/gda-data-select.c b/libgda/gda-data-select.c
index ae8dca6..481e5ba 100644
--- a/libgda/gda-data-select.c
+++ b/libgda/gda-data-select.c
@@ -3470,8 +3470,8 @@ gda_data_select_rerun (GdaDataSelect *model, GError **error)
 	for (l1 = model->priv->sh->columns, l2 = old_model->priv->sh->columns;
 	     l1 && l2;
 	     l1 = l1->next, l2 = l2->next) {
-		if ((gda_column_get_g_type ((GdaColumn*) l1->data) == GDA_TYPE_NULL) &&
-		    (gda_column_get_g_type ((GdaColumn*) l2->data) != GDA_TYPE_NULL))
+		if ((gda_column_get_g_type ((GdaColumn*) l1->data) == G_TYPE_INVALID) &&
+		    (gda_column_get_g_type ((GdaColumn*) l2->data) != G_TYPE_INVALID))
 			gda_column_set_g_type ((GdaColumn*) l1->data, 
 					       gda_column_get_g_type ((GdaColumn*) l2->data));
 	}
diff --git a/libgda/gda-holder.c b/libgda/gda-holder.c
index e7e2f30..27961c3 100644
--- a/libgda/gda-holder.c
+++ b/libgda/gda-holder.c
@@ -32,8 +32,6 @@
 #include <libgda/gda-custom-marshal.h>
 #include <libgda/gda-types.h>
 
-#define __gda_value_is_null(value) (!G_IS_VALUE (value))
-
 /* 
  * Main static functions 
  */
@@ -575,7 +573,7 @@ gda_holder_set_property (GObject *object,
 			gda_holder_set_attribute_static (holder, GDA_ATTRIBUTE_DESCRIPTION, value);
 			break;
 		case PROP_GDA_TYPE:
-			if (holder->priv->g_type == GDA_TYPE_NULL) {
+			if (holder->priv->g_type == G_TYPE_INVALID) {
 				holder->priv->g_type = g_value_get_gtype (value);
 				g_object_notify ((GObject*) holder, "g-type");
 			}
@@ -589,11 +587,11 @@ gda_holder_set_property (GObject *object,
 				
 				/* updating the holder's validity regarding the NULL value */
 				if (!not_null && 
-				    (!holder->priv->value || __gda_value_is_null (holder->priv->value)))
+				    (!holder->priv->value || gda_value_is_null (holder->priv->value)))
 					holder->priv->valid = TRUE;
 				
 				if (not_null && 
-				    (!holder->priv->value || __gda_value_is_null (holder->priv->value)))
+				    (!holder->priv->value || gda_value_is_null (holder->priv->value)))
 					holder->priv->valid = FALSE;
 				
 				g_signal_emit (holder, gda_holder_signals[CHANGED], 0);
@@ -772,7 +770,7 @@ gda_holder_get_value_str (GdaHolder *holder, GdaDataHandler *dh)
 	g_return_val_if_fail (holder->priv, NULL);
 
 	current_val = gda_holder_get_value (holder);
-        if (!current_val || __gda_value_is_null (current_val))
+        if (!current_val || gda_value_is_null (current_val))
                 return NULL;
         else {
                 if (!dh)
@@ -801,7 +799,7 @@ static gboolean real_gda_holder_set_value (GdaHolder *holder, GValue *value, gbo
  * If the value is not different from the one already contained within @holder,
  * then @holder is not changed and no signal is emitted.
  *
- * Note1: the @value argument is treated the same way if it is %NULL or if it is a #GDA_TYPE_NULL value
+ * Note1: the @value argument is treated the same way if it is %NULL or if it is a G_TYPE_INVALID or #GDA_TYPE_NULL value
  *
  * Note2: if @holder can't accept the @value value, then this method returns FALSE, and @holder will be left
  * in an invalid state.
@@ -924,11 +922,11 @@ real_gda_holder_set_value (GdaHolder *holder, GValue *value, gboolean do_copy, G
 	}
 		
 	/* holder will be changed? */
-	newnull = !value || __gda_value_is_null (value);
+	newnull = !value || gda_value_is_null (value);
 	current_val = gda_holder_get_value (holder);
 	if (current_val == value)
 		changed = FALSE;
-	else if ((!current_val || __gda_value_is_null ((GValue *)current_val)) && newnull)
+	else if ((!current_val || gda_value_is_null ((GValue *)current_val)) && newnull)
 		changed = FALSE;
 	else if (value && current_val &&
 		 (G_VALUE_TYPE (value) == G_VALUE_TYPE ((GValue *)current_val)))
@@ -999,7 +997,7 @@ real_gda_holder_set_value (GdaHolder *holder, GValue *value, gboolean do_copy, G
 	/* check is the new value is the default one */
 	holder->priv->default_forced = FALSE;
 	if (holder->priv->default_value) {
-		if ((G_VALUE_TYPE (holder->priv->default_value) == GDA_TYPE_NULL) && newnull)
+		if ((G_VALUE_TYPE (holder->priv->default_value) == G_TYPE_INVALID) && newnull)
 			holder->priv->default_forced = TRUE;
 		else if ((G_VALUE_TYPE (holder->priv->default_value) == holder->priv->g_type) &&
 			 value && (G_VALUE_TYPE (value) == holder->priv->g_type))
@@ -1058,11 +1056,11 @@ real_gda_holder_set_const_value (GdaHolder *holder, const GValue *value,
 #endif
 
 	/* holder will be changed? */
-	newnull = !value || __gda_value_is_null (value);
+	newnull = !value || gda_value_is_null (value);
 	current_val = gda_holder_get_value (holder);
 	if (current_val == value)
 		changed = FALSE;
-	else if ((!current_val || __gda_value_is_null (current_val)) && newnull) 
+	else if ((!current_val || gda_value_is_null (current_val)) && newnull)
 		changed = FALSE;
 	else if (value && current_val &&
 		 (G_VALUE_TYPE (value) == G_VALUE_TYPE (current_val))) 
@@ -1130,7 +1128,7 @@ real_gda_holder_set_const_value (GdaHolder *holder, const GValue *value,
 	/* check is the new value is the default one */
 	holder->priv->default_forced = FALSE;
 	if (holder->priv->default_value) {
-		if ((G_VALUE_TYPE (holder->priv->default_value) == GDA_TYPE_NULL) && newnull)
+		if ((G_VALUE_TYPE (holder->priv->default_value) == G_TYPE_INVALID) && newnull)
 			holder->priv->default_forced = TRUE;
 		else if ((G_VALUE_TYPE (holder->priv->default_value) == holder->priv->g_type) &&
 			 value && (G_VALUE_TYPE (value) == holder->priv->g_type))
@@ -1386,8 +1384,8 @@ gda_holder_set_default_value (GdaHolder *holder, const GValue *value)
 		const GValue *current = gda_holder_get_value (holder);
 
 		/* check if default is equal to current value */
-		if (__gda_value_is_null (value) &&
-		    (!current || __gda_value_is_null (current)))
+		if (gda_value_is_null (value) &&
+		    (!current || gda_value_is_null (current)))
 			holder->priv->default_forced = TRUE;
 		else if ((G_VALUE_TYPE (value) == holder->priv->g_type) &&
 			 current && !gda_value_compare (value, current))
@@ -1472,7 +1470,7 @@ gda_holder_set_source_model (GdaHolder *holder, GdaDataModel *model,
 		gcol = gda_data_model_describe_column (model, col);
 		if (gcol) {
 			ctype = gda_column_get_g_type (gcol);
-			if ((htype != GDA_TYPE_NULL) && (ctype != GDA_TYPE_NULL) &&
+			if ((htype != G_TYPE_INVALID) && (ctype != G_TYPE_INVALID) &&
 			    (htype != ctype)) {
 				g_set_error (error, GDA_HOLDER_ERROR, GDA_HOLDER_VALUE_TYPE_ERROR,
 					     _("GdaHolder has a gda type (%s) incompatible with "
@@ -1538,7 +1536,7 @@ gda_holder_get_source_model (GdaHolder *holder, gint *col)
 }
 
 /*
- * This callback is called when @holder->priv->simple_bind's GType was GDA_TYPE_NULL at the time
+ * This callback is called when @holder->priv->simple_bind's GType was G_TYPE_INVALID at the time
  * gda_holder_set_bind() was called, and it makes sure @holder's GType is the same as @holder->priv->simple_bind's
  */
 static void
@@ -1547,7 +1545,7 @@ bind_to_notify_cb (GdaHolder *bind_to, G_GNUC_UNUSED GParamSpec *pspec, GdaHolde
 	g_signal_handler_disconnect (holder->priv->simple_bind,
 				     holder->priv->simple_bind_notify_signal_id);
 	holder->priv->simple_bind_notify_signal_id = 0;
-	if (holder->priv->g_type == GDA_TYPE_NULL) {
+	if (holder->priv->g_type == G_TYPE_INVALID) {
 		holder->priv->g_type = bind_to->priv->g_type;
 		g_object_notify ((GObject*) holder, "g-type");
 	}
@@ -1568,8 +1566,8 @@ bind_to_notify_cb (GdaHolder *bind_to, G_GNUC_UNUSED GParamSpec *pspec, GdaHolde
  *
  * Sets @holder to change when @bind_to changes (and does not make @bind_to change when @holder changes).
  * For the operation to succeed, the GType of @holder and @bind_to must be the same, with the exception that
- * any of them can have a %GDA_TYPE_NULL type (in this situation, the GType of the two #GdaHolder objects
- * involved is set to match the other when any of them sets its type to something different than GDA_TYPE_NULL).
+ * any of them can have a %G_TYPE_INVALID type (in this situation, the GType of the two #GdaHolder objects
+ * involved is set to match the other when any of them sets its type to something different than G_TYPE_INVALI).
  *
  * If @bind_to is %NULL, then @holder will not be bound anymore.
  *
@@ -1594,8 +1592,8 @@ gda_holder_set_bind (GdaHolder *holder, GdaHolder *bind_to, GError **error)
 		g_return_val_if_fail (GDA_IS_HOLDER (bind_to), FALSE);
 		g_return_val_if_fail (bind_to->priv, FALSE);
 		
-		if ((holder->priv->g_type != GDA_TYPE_NULL) &&
-		    (bind_to->priv->g_type != GDA_TYPE_NULL) &&
+		if ((holder->priv->g_type != G_TYPE_INVALID) &&
+		    (bind_to->priv->g_type != G_TYPE_INVALID) &&
 		    (holder->priv->g_type != bind_to->priv->g_type)) {
 			g_set_error (error, GDA_HOLDER_ERROR, GDA_HOLDER_VALUE_TYPE_ERROR,
 				     "%s", _("Cannot bind holders if their type is not the same"));
@@ -1628,11 +1626,11 @@ gda_holder_set_bind (GdaHolder *holder, GdaHolder *bind_to, GError **error)
 		g_signal_connect (G_OBJECT (holder->priv->simple_bind), "changed",
 				  G_CALLBACK (full_bind_changed_cb), holder);
 
-		if (bind_to->priv->g_type == GDA_TYPE_NULL)
+		if (bind_to->priv->g_type == G_TYPE_INVALID)
 			holder->priv->simple_bind_notify_signal_id = g_signal_connect (bind_to, "notify::g-type",
 										       G_CALLBACK (bind_to_notify_cb),
 										       holder);
-		else if (holder->priv->g_type == GDA_TYPE_NULL)
+		else if (holder->priv->g_type == G_TYPE_INVALID)
 			g_object_set ((GObject*) holder, "g-type", bind_to->priv->g_type , NULL);
 
 		/* if bind_to has a different value than holder, then we set holder to the new value */
@@ -1671,12 +1669,12 @@ gda_holder_set_full_bind (GdaHolder *holder, GdaHolder *alias_of)
 		g_return_if_fail (alias_of->priv);
 		g_return_if_fail (holder->priv->g_type == alias_of->priv->g_type);
 		cvalue = gda_holder_get_value (alias_of);
-		if (cvalue && !__gda_value_is_null ((GValue*)cvalue))
+		if (cvalue && ! gda_value_is_null ((GValue*)cvalue))
 			value2 = gda_value_copy ((GValue*)cvalue);
 	}
 
 	cvalue = gda_holder_get_value (holder);
-	if (cvalue && !__gda_value_is_null ((GValue*)cvalue))
+	if (cvalue && ! gda_value_is_null ((GValue*)cvalue))
 		value1 = gda_value_copy ((GValue*)cvalue);
 		
 	
diff --git a/libgda/gda-meta-struct.c b/libgda/gda-meta-struct.c
index 996f7a8..10ca633 100644
--- a/libgda/gda-meta-struct.c
+++ b/libgda/gda-meta-struct.c
@@ -385,9 +385,9 @@ get_user_obj_name (const GValue *catalog, const GValue *schema, const GValue *na
 {
 	GString *string = NULL;
 	gchar *ret;
-	if (catalog && (G_VALUE_TYPE (catalog) != GDA_TYPE_NULL))
+	if (catalog && (G_VALUE_TYPE (catalog) != G_TYPE_INVALID))
 		string = g_string_new (g_value_get_string (catalog));
-	if (schema && (G_VALUE_TYPE (schema) != GDA_TYPE_NULL)) {
+	if (schema && (G_VALUE_TYPE (schema) != G_TYPE_INVALID)) {
 		if (string) {
 			g_string_append_c (string, '.');
 			g_string_append (string, g_value_get_string (schema));
@@ -395,7 +395,7 @@ get_user_obj_name (const GValue *catalog, const GValue *schema, const GValue *na
 		else
 			string = g_string_new (g_value_get_string (schema));
 	}
-	if (name && (G_VALUE_TYPE (name) != GDA_TYPE_NULL)) {
+	if (name && (G_VALUE_TYPE (name) != G_TYPE_INVALID)) {
 		if (string) {
 			g_string_append_c (string, '.');
 			g_string_append (string, g_value_get_string (name));
@@ -890,14 +890,14 @@ _meta_struct_complement (GdaMetaStruct *mstruct, GdaMetaDbObjectType type,
 		mv = GDA_META_VIEW (dbo);
 		cvalue = gda_data_model_get_value_at (model, 0, 0, error);
 		if (!cvalue) goto onerror;
-		if (G_VALUE_TYPE (cvalue) != GDA_TYPE_NULL)
+		if (G_VALUE_TYPE (cvalue) != G_TYPE_INVALID)
 			mv->view_def = g_value_dup_string (cvalue);
 		else
 			mv->view_def = g_strdup ("");
 
 		cvalue = gda_data_model_get_value_at (model, 1, 0, error);
 		if (!cvalue) goto onerror;
-		if (G_VALUE_TYPE (cvalue) != GDA_TYPE_NULL)
+		if (G_VALUE_TYPE (cvalue) != G_TYPE_INVALID)
 			mv->is_updatable = g_value_get_boolean (cvalue);
 		else
 			mv->is_updatable = FALSE;
diff --git a/libgda/gda-server-operation.c b/libgda/gda-server-operation.c
index ec7bade..b28ceb3 100644
--- a/libgda/gda-server-operation.c
+++ b/libgda/gda-server-operation.c
@@ -2108,7 +2108,7 @@ gda_server_operation_get_sql_identifier_at (GdaServerOperation *op, GdaConnectio
 	value = real_gda_server_operation_get_value_at (op, path);
 	g_free (path);
 
-	if (!value || (G_VALUE_TYPE (value) == GDA_TYPE_NULL))
+	if (!value || (G_VALUE_TYPE (value) == G_TYPE_INVALID))
 		return NULL;
 	g_return_val_if_fail (G_VALUE_TYPE (value) == G_TYPE_STRING, NULL);
 
diff --git a/libgda/gda-set.c b/libgda/gda-set.c
index bb89784..c970f23 100644
--- a/libgda/gda-set.c
+++ b/libgda/gda-set.c
@@ -323,7 +323,7 @@ gda_set_class_init (GdaSetClass *class)
 	 * @holder: the #GdaHolder for which the #GType has been set
 	 *
 	 * Gets emitted when @holder in @set has its type finally set, in case
-	 * it was #GDA_TYPE_NULL
+	 * it was #G_TYPE_INVALID
 	 *
 	 * Since: 4.2
 	 */
@@ -1267,7 +1267,7 @@ holder_notify_cb (GdaHolder *holder, GParamSpec *pspec, GdaSet *dataset)
 	GType gtype;
 	gtype = gda_holder_get_g_type (holder);
 	if (!strcmp (pspec->name, "g-type")) {
-		g_assert (gtype != GDA_TYPE_NULL);
+		g_assert (gtype != G_TYPE_INVALID);
 		g_signal_emit (dataset, gda_set_signals[HOLDER_TYPE_SET], 0, holder);
 	}
 	else if (!strcmp (pspec->name, "name")) {
@@ -1328,7 +1328,7 @@ gda_set_real_add_holder (GdaSet *set, GdaHolder *holder)
 			g_signal_connect (G_OBJECT (holder), "attribute-changed",
 					  G_CALLBACK (att_holder_changed_cb), set);
 		}
-		if (gda_holder_get_g_type (holder) == GDA_TYPE_NULL)
+		if (gda_holder_get_g_type (holder) == G_TYPE_INVALID)
 			g_signal_connect (G_OBJECT (holder), "notify::g-type",
 					  G_CALLBACK (holder_notify_cb), set);
 		g_signal_connect (G_OBJECT (holder), "notify::name",
@@ -1648,7 +1648,7 @@ gda_set_replace_source_model (GdaSet *set, GdaSetSource *source, GdaDataModel *m
 		t1 = gda_column_get_g_type (c1);
 		t2 = gda_column_get_g_type (c2);
 
-		if ((t1 != GDA_TYPE_NULL) && (t2 != GDA_TYPE_NULL) && (t1 != t2)) {
+		if ((t1 != G_TYPE_INVALID) && (t2 != G_TYPE_INVALID) && (t1 != t2)) {
 			g_warning (_("Replacing data model must have the same characteristics as the "
 				     "data model it replaces"));
 			return;
diff --git a/libgda/gda-sql-builder.c b/libgda/gda-sql-builder.c
index 64e56c4..595629d 100644
--- a/libgda/gda-sql-builder.c
+++ b/libgda/gda-sql-builder.c
@@ -810,7 +810,7 @@ gda_sql_builder_add_expr_value (GdaSqlBuilder *builder, GdaDataHandler *dh, cons
 
 	gchar *str;
 
-	if (value && (G_VALUE_TYPE (value) != GDA_TYPE_NULL)) {
+	if (value && (G_VALUE_TYPE (value) != G_TYPE_INVALID)) {
 		GType type = G_VALUE_TYPE (value);
 		if (!dh)
 			dh = gda_data_handler_get_default (type);
diff --git a/libgda/gda-value.c b/libgda/gda-value.c
index 3dfacd2..0c1cc75 100644
--- a/libgda/gda-value.c
+++ b/libgda/gda-value.c
@@ -251,6 +251,66 @@ set_from_string (GValue *value, const gchar *as_string)
 }
 
 /* 
+ * Register the GdaNull type in the GType system
+ */
+
+/* Transform a String GValue to a null*/
+static void
+string_to_null(const GValue *src, GValue *dest)
+{
+	g_return_if_fail (G_VALUE_HOLDS_STRING (src) &&
+			  GDA_VALUE_HOLDS_NULL (dest));
+
+	gda_value_set_null (dest);
+}
+
+static void
+null_to_string (const GValue *src, GValue *dest)
+{
+	gchar *str;
+
+	g_return_if_fail (G_VALUE_HOLDS_STRING (dest) &&
+			  GDA_VALUE_HOLDS_NULL (src) );
+
+	str = g_strdup("NULL");
+
+	g_value_take_string (dest, str);
+}
+
+GType
+gda_null_get_type (void)
+{
+	static GType type = 0;
+
+	if (G_UNLIKELY (type == 0)) {
+		static const GTypeInfo type_info = {
+    			0,			/* class_size */
+    			NULL,		/* base_init */
+    			NULL,		/* base_finalize */
+    			NULL,		/* class_init */
+    			NULL,		/* class_finalize */
+    			NULL,		/* class_data */
+    			0,			/* instance_size */
+    			0,			/* n_preallocs */
+    			NULL,		/* instance_init */
+    			NULL		/* value_table */
+  		};
+
+  		type = g_type_register_static (G_TYPE_INT, "GdaNull", &type_info, 0);
+
+		g_value_register_transform_func(G_TYPE_STRING,
+						type,
+						string_to_null);
+
+		g_value_register_transform_func(type,
+						G_TYPE_STRING,
+						null_to_string);
+	}
+
+	return type;
+}
+
+/*
  * Register the GdaBinary type in the GType system 
  */
 
@@ -1303,7 +1363,7 @@ gboolean
 gda_value_is_null (const GValue *value)
 {
 	g_return_val_if_fail (value, FALSE);
-	return !G_IS_VALUE (value);
+	return G_VALUE_TYPE (value) == GDA_TYPE_NULL;
 }
 
 /**
@@ -1517,6 +1577,7 @@ gda_value_set_null (GValue *value)
 	g_return_if_fail (value);
 
 	l_g_value_unset (value);
+	g_value_init (value, GDA_TYPE_NULL);
 }
 
 /**
diff --git a/libgda/gda-value.h b/libgda/gda-value.h
index 5b2cbc2..05eb30f 100644
--- a/libgda/gda-value.h
+++ b/libgda/gda-value.h
@@ -37,7 +37,7 @@ G_BEGIN_DECLS
 #define GDA_TIMEZONE_INVALID (2*12*60*60)
 
 /* Definition of the GType's values used in GValue*/
-#define GDA_TYPE_NULL 0
+#define GDA_TYPE_NULL (gda_null_get_type())
 #define	GDA_TYPE_BINARY (gda_binary_get_type())
 #define GDA_TYPE_BLOB (gda_blob_get_type())
 #define	GDA_TYPE_GEOMETRIC_POINT (gda_geometricpoint_get_type())
@@ -49,6 +49,7 @@ G_BEGIN_DECLS
 
 
 /* Definition of the GDA_VALUE_HOLDS macros */
+#define GDA_VALUE_HOLDS_NULL(value)            G_VALUE_HOLDS(value, GDA_TYPE_NULL)
 #define GDA_VALUE_HOLDS_BINARY(value)          G_VALUE_HOLDS(value, GDA_TYPE_BINARY)
 #define GDA_VALUE_HOLDS_BLOB(value)            G_VALUE_HOLDS(value, GDA_TYPE_BLOB)
 #define GDA_VALUE_HOLDS_GEOMETRIC_POINT(value) G_VALUE_HOLDS(value, GDA_TYPE_GEOMETRIC_POINT)
@@ -262,6 +263,8 @@ GType                             gda_geometricpoint_get_type (void) G_GNUC_CONS
 gpointer                          gda_geometricpoint_copy (gpointer boxed);
 void                              gda_geometricpoint_free (gpointer boxed);
 
+GType                             gda_null_get_type (void) G_GNUC_CONST;
+
 GType                             gda_binary_get_type (void) G_GNUC_CONST;
 gpointer                          gda_binary_copy (gpointer boxed);
 void                              gda_binary_free (gpointer boxed);
diff --git a/libgda/sqlite/gda-sqlite-meta.c b/libgda/sqlite/gda-sqlite-meta.c
index 4bb9c48..86910bc 100644
--- a/libgda/sqlite/gda-sqlite-meta.c
+++ b/libgda/sqlite/gda-sqlite-meta.c
@@ -408,7 +408,7 @@ fill_udt_model (SqliteConnectionData *cdata, GHashTable *added_hash,
 				continue;
 
 			gtype = GPOINTER_TO_INT (g_hash_table_lookup (cdata->types, typname));
-			if ((gtype == GDA_TYPE_NULL) && !g_hash_table_lookup (added_hash, typname)) {
+			if ((gtype == G_TYPE_INVALID) && !g_hash_table_lookup (added_hash, typname)) {
 				GValue *vname, *vgtyp;
 
 				gtype = _gda_sqlite_compute_g_type (get_affinity (typname));
diff --git a/libgda/sqlite/gda-sqlite-recordset.c b/libgda/sqlite/gda-sqlite-recordset.c
index c6f2c61..0c2b363 100644
--- a/libgda/sqlite/gda-sqlite-recordset.c
+++ b/libgda/sqlite/gda-sqlite-recordset.c
@@ -149,7 +149,7 @@ read_rows_to_init_col_types (GdaSqliteRecordset *model)
 
 	missing_cols = g_new (gint, pmodel->prep_stmt->ncols);
 	for (nb_missing = 0, i = 0; i < pmodel->prep_stmt->ncols; i++) {
-		if (pmodel->prep_stmt->types[i] == GDA_TYPE_NULL)
+		if (pmodel->prep_stmt->types[i] == G_TYPE_INVALID)
 			missing_cols [nb_missing++] = i;
 	}
 	/*
@@ -165,7 +165,7 @@ read_rows_to_init_col_types (GdaSqliteRecordset *model)
 		g_print ("Read row %d for prep stmt %p\n", model->priv->next_row_num - 1, pmodel->prep_stmt);
 #endif
 		for (i = nb_missing - 1; i >= 0; i--) {
-			if (pmodel->prep_stmt->types [missing_cols [i]] != GDA_TYPE_NULL) {
+			if (pmodel->prep_stmt->types [missing_cols [i]] != G_TYPE_INVALID) {
 #ifdef GDA_DEBUG_NO
 				g_print ("Found type '%s' for col %d\n", 
 					 g_type_name (pmodel->prep_stmt->types [missing_cols [i]]),
@@ -225,7 +225,7 @@ _gda_sqlite_recordset_new (GdaConnection *cnc, GdaSqlitePStmt *ps, GdaSet *exec_
 		_GDA_PSTMT (ps)->tmpl_columns = g_slist_reverse (_GDA_PSTMT (ps)->tmpl_columns);
 
 		/* create prepared statement's types */
-		_GDA_PSTMT (ps)->types = g_new0 (GType, _GDA_PSTMT (ps)->ncols); /* all types are initialized to GDA_TYPE_NULL */
+		_GDA_PSTMT (ps)->types = g_new0 (GType, _GDA_PSTMT (ps)->ncols); /* all types are initialized to G_TYPE_INVALID */
 		if (col_types) {
 			for (i = 0; ; i++) {
 				if (col_types [i] > 0) {
@@ -251,7 +251,7 @@ _gda_sqlite_recordset_new (GdaConnection *cnc, GdaSqlitePStmt *ps, GdaSet *exec_
 			gda_column_set_description (column, SQLITE3_CALL (sqlite3_column_name) (ps->sqlite_stmt, real_col));
 			gda_column_set_name (column, SQLITE3_CALL (sqlite3_column_name) (ps->sqlite_stmt, real_col));
 			gda_column_set_dbms_type (column, SQLITE3_CALL (sqlite3_column_decltype) (ps->sqlite_stmt, real_col));
-			if (_GDA_PSTMT (ps)->types [i] != GDA_TYPE_NULL)
+			if (_GDA_PSTMT (ps)->types [i] != G_TYPE_INVALID)
 				gda_column_set_g_type (column, _GDA_PSTMT (ps)->types [i]);
 		}
         }
@@ -281,10 +281,10 @@ static GType
 fuzzy_get_gtype (SqliteConnectionData *cdata, GdaSqlitePStmt *ps, gint colnum)
 {
 	const gchar *ctype;
-	GType gtype = GDA_TYPE_NULL;
+	GType gtype = G_TYPE_INVALID;
 	gint real_col = colnum + ps->nb_rowid_columns;
 
-	if (_GDA_PSTMT (ps)->types [colnum] != GDA_TYPE_NULL)
+	if (_GDA_PSTMT (ps)->types [colnum] != G_TYPE_INVALID)
 		return _GDA_PSTMT (ps)->types [colnum];
 	
 	ctype = SQLITE3_CALL (sqlite3_column_origin_name) (ps->sqlite_stmt, real_col);
@@ -295,7 +295,7 @@ fuzzy_get_gtype (SqliteConnectionData *cdata, GdaSqlitePStmt *ps, gint colnum)
 		
 		if (ctype)
 			gtype = GPOINTER_TO_INT (g_hash_table_lookup (cdata->types, ctype));
-		if (gtype == GDA_TYPE_NULL) 
+		if (gtype == G_TYPE_INVALID)
 			gtype = _gda_sqlite_compute_g_type (SQLITE3_CALL (sqlite3_column_type) (ps->sqlite_stmt, real_col));
 	}
 
@@ -331,7 +331,7 @@ fetch_next_sqlite_row (GdaSqliteRecordset *model, gboolean do_store, GError **er
 			
 			real_col = col + ps->nb_rowid_columns;
 
-			if (type == GDA_TYPE_NULL) {
+			if (type == G_TYPE_INVALID) {
 				type = fuzzy_get_gtype (cdata, ps, col);
 				if (type == GDA_TYPE_BLOB) {
 					/* extra check: make sure we have a rowid for this blob, or fallback to binary */
@@ -354,7 +354,7 @@ fetch_next_sqlite_row (GdaSqliteRecordset *model, gboolean do_store, GError **er
 					else
 						type = GDA_TYPE_BINARY;
 				}
-				if (type != GDA_TYPE_NULL) {
+				if (type != G_TYPE_INVALID) {
 					GdaColumn *column;
 					
 					_GDA_PSTMT (ps)->types [col] = type;
@@ -372,7 +372,7 @@ fetch_next_sqlite_row (GdaSqliteRecordset *model, gboolean do_store, GError **er
 				gda_value_set_null (value);
 			}
 			else {
-				if (type != GDA_TYPE_NULL)
+				if (type != G_TYPE_INVALID)
 					g_value_init (value, type);
 				
 				if (type == GDA_TYPE_NULL)
diff --git a/libgda/sqlite/virtual/gda-vconnection-hub.c b/libgda/sqlite/virtual/gda-vconnection-hub.c
index efda161..1b32363 100644
--- a/libgda/sqlite/virtual/gda-vconnection-hub.c
+++ b/libgda/sqlite/virtual/gda-vconnection-hub.c
@@ -578,7 +578,7 @@ create_value_from_sqlite3_gvalue (GType type, GValue *svalue, GError **error)
 	gboolean allok = TRUE;
 	value = g_new0 (GValue, 1);
 
-	if (type != GDA_TYPE_NULL)
+	if (type != G_TYPE_INVALID)
 		g_value_init (value, type);
 
 	if (type == GDA_TYPE_NULL)
diff --git a/libgda/sqlite/virtual/gda-vprovider-data-model.c b/libgda/sqlite/virtual/gda-vprovider-data-model.c
index 8b6f423..b217fb5 100644
--- a/libgda/sqlite/virtual/gda-vprovider-data-model.c
+++ b/libgda/sqlite/virtual/gda-vprovider-data-model.c
@@ -633,7 +633,7 @@ virtualRowid (sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid)
 			GValue *gvalue;
 			cvalue = gda_data_model_iter_get_value_at (cursor->iter, i);
 			gvalue = gda_row_get_value (grow, i);
-			if (G_VALUE_TYPE (cvalue) != GDA_TYPE_NULL) {
+			if (G_VALUE_TYPE (cvalue) != G_TYPE_INVALID) {
 				g_value_init (gvalue, G_VALUE_TYPE (cvalue));
 				g_value_copy (cvalue, gvalue);
 			}
@@ -751,7 +751,7 @@ virtual_table_manage_real_data_model (VirtualTable *vtable, int idxNum, const ch
 		     i++, list = list->next) {
 			GdaColumn *mcol = gda_data_model_describe_column (vtable->td->real_model, i);
 			GdaColumn *ccol = (GdaColumn*) list->data;
-			if (gda_column_get_g_type (mcol) == GDA_TYPE_NULL)
+			if (gda_column_get_g_type (mcol) == G_TYPE_INVALID)
 				gda_column_set_g_type (mcol, gda_column_get_g_type (ccol));
 		}
 	}
@@ -1080,7 +1080,7 @@ virtualUpdate (sqlite3_vtab *tab, int nData, sqlite3_value **apData, sqlite_int6
 					GType type;
 					GValue *value;
 					type = gda_column_get_g_type (gda_data_model_describe_column (vtable->td->real_model, i));
-					if ((type != GDA_TYPE_NULL) && SQLITE3_CALL (sqlite3_value_text) (apData [i+2]))
+					if ((type != G_TYPE_INVALID) && SQLITE3_CALL (sqlite3_value_text) (apData [i+2]))
 						value = gda_value_new_from_string ((const gchar*) SQLITE3_CALL (sqlite3_value_text) (apData [i+2]), type);
 					else
 						value = gda_value_new_null ();
@@ -1198,7 +1198,7 @@ virtualUpdate (sqlite3_vtab *tab, int nData, sqlite3_value **apData, sqlite_int6
 			GType type;
 			GValue *value;
 			type = gda_column_get_g_type (gda_data_model_describe_column (vtable->td->real_model, i - 2));
-			if ((type != GDA_TYPE_NULL) && SQLITE3_CALL (sqlite3_value_text) (apData [i]))
+			if ((type != G_TYPE_INVALID) && SQLITE3_CALL (sqlite3_value_text) (apData [i]))
 				value = gda_value_new_from_string ((const gchar*) SQLITE3_CALL (sqlite3_value_text) (apData [i]), type);
 			else
 				value = gda_value_new_null ();
diff --git a/libgda/thread-wrapper/gda-thread-wrapper.c b/libgda/thread-wrapper/gda-thread-wrapper.c
index eb4ba48..d252dbc 100644
--- a/libgda/thread-wrapper/gda-thread-wrapper.c
+++ b/libgda/thread-wrapper/gda-thread-wrapper.c
@@ -102,7 +102,7 @@ job_free (Job *job)
 		guint i;
 		for (i = 0; i < job->u.signal.n_param_values; i++) {
 			GValue *value = job->u.signal.param_values + i;
-			if (G_VALUE_TYPE (value) != GDA_TYPE_NULL)
+			if (G_VALUE_TYPE (value) != G_TYPE_INVALID)
 				g_value_reset (value);
 		}
 		g_free (job->u.signal.param_values);
@@ -966,7 +966,7 @@ worker_thread_closure_marshal (GClosure *closure,
 		src = param_values + i;
 		dest = job->u.signal.param_values + i - 1;
 
-		if (G_VALUE_TYPE (src) != GDA_TYPE_NULL) {
+		if (G_VALUE_TYPE (src) != G_TYPE_INVALID) {
 			g_value_init (dest, G_VALUE_TYPE (src));
 			g_value_copy (src, dest);
 		}
@@ -1008,7 +1008,7 @@ worker_thread_closure_marshal_anythread (GClosure *closure,
 		src = param_values + i;
 		dest = job->u.signal.param_values + i - 1;
 
-		if (G_VALUE_TYPE (src) != GDA_TYPE_NULL) {
+		if (G_VALUE_TYPE (src) != G_TYPE_INVALID) {
 			g_value_init (dest, G_VALUE_TYPE (src));
 			g_value_copy (src, dest);
 		}
diff --git a/providers/firebird/gda-firebird-recordset.c b/providers/firebird/gda-firebird-recordset.c
index 359889b..907c9f3 100644
--- a/providers/firebird/gda-firebird-recordset.c
+++ b/providers/firebird/gda-firebird-recordset.c
@@ -167,7 +167,7 @@ gda_firebird_recordset_new (GdaConnection *cnc, GdaFirebirdPStmt *ps, GdaDataMod
 		_GDA_PSTMT (ps)->tmpl_columns = g_slist_reverse (_GDA_PSTMT (ps)->tmpl_columns);
 
 		/* create prepared statement's types */
-		_GDA_PSTMT (ps)->types = g_new0 (GType, _GDA_PSTMT (ps)->ncols); /* all types are initialized to GDA_TYPE_NULL */
+		_GDA_PSTMT (ps)->types = g_new0 (GType, _GDA_PSTMT (ps)->ncols); /* all types are initialized to G_TYPE_INVALID */
 		if (col_types) {
 			for (i = 0; ; i++) {
 				if (col_types [i] > 0) {
diff --git a/providers/jdbc/gda-jdbc-provider.c b/providers/jdbc/gda-jdbc-provider.c
index 2818b25..f7cc32d 100644
--- a/providers/jdbc/gda-jdbc-provider.c
+++ b/providers/jdbc/gda-jdbc-provider.c
@@ -1408,7 +1408,7 @@ gda_jdbc_provider_statement_execute (GdaServerProvider *provider, GdaConnection
 		const GValue *value = gda_holder_get_value (h);
 		jexec_res = jni_wrapper_method_call (jenv, GdaJPStmt__setParameterValue,
 						     ps->pstmt_obj, NULL, NULL, &lerror, i, 
-						     (G_VALUE_TYPE (value) == GDA_TYPE_NULL) ? (glong) 0 : (glong) value);
+						     (G_VALUE_TYPE (value) == G_TYPE_INVALID) ? (glong) 0 : (glong) value);
 		if (!jexec_res) {
 			event = gda_connection_point_available_event (cnc, GDA_CONNECTION_EVENT_ERROR);
 			if (lerror)
diff --git a/providers/jdbc/gda-jdbc-recordset.c b/providers/jdbc/gda-jdbc-recordset.c
index 4f9ec11..c9403d1 100644
--- a/providers/jdbc/gda-jdbc-recordset.c
+++ b/providers/jdbc/gda-jdbc-recordset.c
@@ -269,7 +269,7 @@ gda_jdbc_recordset_new (GdaConnection *cnc, GdaJdbcPStmt *ps, GdaSet *exec_param
 		_GDA_PSTMT (ps)->tmpl_columns = g_slist_reverse (_GDA_PSTMT (ps)->tmpl_columns);
 
 		/* create prepared statement's types */
-		_GDA_PSTMT (ps)->types = g_new0 (GType, _GDA_PSTMT (ps)->ncols); /* all types are initialized to GDA_TYPE_NULL */
+		_GDA_PSTMT (ps)->types = g_new0 (GType, _GDA_PSTMT (ps)->ncols); /* all types are initialized to G_TYPE_INVALID */
 		if (col_types) {
 			for (i = 0; ; i++) {
 				if (col_types [i] > 0) {
@@ -303,7 +303,7 @@ gda_jdbc_recordset_new (GdaConnection *cnc, GdaJdbcPStmt *ps, GdaSet *exec_param
 			column = GDA_COLUMN (list->data);
 			jcol_a = jni_wrapper_field_get (jenv, GdaJColumnInfos__col_name, jcol_v, NULL);
 			if (jcol_a) {
-				if (G_VALUE_TYPE (jcol_a) != GDA_TYPE_NULL)
+				if (G_VALUE_TYPE (jcol_a) != G_TYPE_INVALID)
 					gda_column_set_name (column, g_value_get_string (jcol_a));
 				gda_value_free (jcol_a);
 			}
@@ -311,7 +311,7 @@ gda_jdbc_recordset_new (GdaConnection *cnc, GdaJdbcPStmt *ps, GdaSet *exec_param
 				allok = FALSE;
 			jcol_a = jni_wrapper_field_get (jenv, GdaJColumnInfos__col_descr, jcol_v, NULL);
 			if (jcol_a) {
-				if (G_VALUE_TYPE (jcol_a) != GDA_TYPE_NULL)
+				if (G_VALUE_TYPE (jcol_a) != G_TYPE_INVALID)
 					gda_column_set_description (column, g_value_get_string (jcol_a));
 				gda_value_free (jcol_a);
 			}
diff --git a/providers/jdbc/gda-jdbc-util.c b/providers/jdbc/gda-jdbc-util.c
index cdf1408..66858bb 100644
--- a/providers/jdbc/gda-jdbc-util.c
+++ b/providers/jdbc/gda-jdbc-util.c
@@ -139,5 +139,5 @@ _gda_jdbc_gtype_to_proto_type (GType type)
 	else if (type == GDA_TYPE_NUMERIC)
 		return 14;
 	else
-		return 0; /* GDA_TYPE_NULL */
+		return G_TYPE_INVALID;
 }
diff --git a/providers/jdbc/jni-wrapper.c b/providers/jdbc/jni-wrapper.c
index b4e44b6..6746878 100644
--- a/providers/jdbc/jni-wrapper.c
+++ b/providers/jdbc/jni-wrapper.c
@@ -365,7 +365,7 @@ jni_wrapper_handle_exception (JNIEnv *jenv, gint *out_error_code, gchar **out_sq
 					g_free (res);
 				}
 				else {
-					if (G_VALUE_TYPE (res) != 0) /* GDA_TYPE_NULL */
+					if (G_VALUE_TYPE (res) != G_TYPE_INVALID)
 						g_value_unset (res);
 					g_free (res);
 					goto fallback;
@@ -448,7 +448,7 @@ jni_wrapper_method_create (JNIEnv *jenv, jclass klass,
  *
  * Executes an instance method.
  *
- * Returns: a GValue (may return a GDA_TYPE_NULL value for functions returning void), or %NULL if an error occurred
+ * Returns: a GValue (may return a G_TYPE_INVALID value for functions returning void), or %NULL if an error occurred
  */
 GValue *
 jni_wrapper_method_call (JNIEnv *jenv, JniWrapperMethod *method, GValue *object, 
@@ -679,7 +679,7 @@ jni_wrapper_field_create (JNIEnv *jenv, jclass klass,
  *
  * Set the value of a static field or an instance's field.
  *
- * Returns: a GValue (may return a GDA_TYPE_NULL value for functions returning void), or %NULL if an error occurred
+ * Returns: a GValue (may return a G_TYPE_INVALID value for functions returning void), or %NULL if an error occurred
  */
 GValue *
 jni_wrapper_field_get (JNIEnv *jenv, JniWrapperField *field, GValue *object, GError **error)
diff --git a/providers/mysql/gda-mysql-recordset.c b/providers/mysql/gda-mysql-recordset.c
index f95194a..c419209 100644
--- a/providers/mysql/gda-mysql-recordset.c
+++ b/providers/mysql/gda-mysql-recordset.c
@@ -481,7 +481,7 @@ gda_mysql_recordset_new_direct (GdaConnection *cnc, GdaDataModelAccessFlags flag
 			GType type = model->priv->types[i];
 			char *data = mysql_row[i];
 
-			if (!data || (type == GDA_TYPE_NULL))
+			if (!data || (type == G_TYPE_INVALID))
 				continue;
 
 			gda_value_reset_with_type (value, type);
@@ -552,7 +552,7 @@ gda_mysql_recordset_new (GdaConnection            *cnc,
 		_GDA_PSTMT (ps)->tmpl_columns = g_slist_reverse (_GDA_PSTMT (ps)->tmpl_columns);
 
 		/* create prepared statement's types */
-		_GDA_PSTMT (ps)->types = g_new0 (GType, _GDA_PSTMT (ps)->ncols); /* all types are initialized to GDA_TYPE_NULL */
+		_GDA_PSTMT (ps)->types = g_new0 (GType, _GDA_PSTMT (ps)->ncols); /* all types are initialized to G_TYPE_INVALID */
 		if (col_types) {
 			for (i = 0; ; i++) {
 				if (col_types [i] > 0) {
diff --git a/providers/oracle/gda-oracle-recordset.c b/providers/oracle/gda-oracle-recordset.c
index 7a429b9..e0fdd52 100644
--- a/providers/oracle/gda-oracle-recordset.c
+++ b/providers/oracle/gda-oracle-recordset.c
@@ -224,7 +224,7 @@ gda_oracle_recordset_new (GdaConnection *cnc, GdaOraclePStmt *ps, GdaSet *exec_p
 		_GDA_PSTMT (ps)->tmpl_columns = g_slist_reverse (_GDA_PSTMT (ps)->tmpl_columns);
 
 		/* create prepared statement's types */
-		_GDA_PSTMT (ps)->types = g_new0 (GType, _GDA_PSTMT (ps)->ncols); /* all types are initialized to GDA_TYPE_NULL */
+		_GDA_PSTMT (ps)->types = g_new0 (GType, _GDA_PSTMT (ps)->ncols); /* all types are initialized to G_TYPE_INVALID */
 		if (col_types) {
 			for (i = 0; ; i++) {
 				if (col_types [i] > 0) {
@@ -342,7 +342,7 @@ gda_oracle_recordset_new (GdaConnection *cnc, GdaOraclePStmt *ps, GdaSet *exec_p
 			g_free (name_buffer);
 
 			/* for data fetching  */
-			if (_GDA_PSTMT (ps)->types [i] != GDA_TYPE_NULL)
+			if (_GDA_PSTMT (ps)->types [i] != G_TYPE_INVALID)
 				ora_value->sql_type = _g_type_to_oracle_sqltype (_GDA_PSTMT (ps)->types [i]);
 
 			switch (ora_value->sql_type) {
@@ -389,7 +389,7 @@ gda_oracle_recordset_new (GdaConnection *cnc, GdaOraclePStmt *ps, GdaSet *exec_p
 				break;
 			}
 			
-			if (_GDA_PSTMT (ps)->types [i] != GDA_TYPE_NULL)
+			if (_GDA_PSTMT (ps)->types [i] != G_TYPE_INVALID)
 				ora_value->g_type = _GDA_PSTMT (ps)->types [i];
 			else
 				ora_value->g_type = _oracle_sqltype_to_g_type (ora_value->sql_type, ora_value->precision, 
@@ -418,7 +418,7 @@ gda_oracle_recordset_new (GdaConnection *cnc, GdaOraclePStmt *ps, GdaSet *exec_p
 				ora_value->value = g_malloc0 (ora_value->defined_size);
 			
 			ora_value->s_type = gda_g_type_to_static_type (ora_value->g_type);
-			if (_GDA_PSTMT (ps)->types [i] == GDA_TYPE_NULL)
+			if (_GDA_PSTMT (ps)->types [i] == G_TYPE_INVALID)
 				_GDA_PSTMT (ps)->types [i] = ora_value->g_type;
 			gda_column_set_g_type (column, ora_value->g_type);
 
diff --git a/providers/oracle/gda-oracle-util.c b/providers/oracle/gda-oracle-util.c
index be066b9..7e165a6 100644
--- a/providers/oracle/gda-oracle-util.c
+++ b/providers/oracle/gda-oracle-util.c
@@ -412,7 +412,7 @@ _gda_value_to_oracle_value (const GValue *value)
 	ora_value->pard = (OCIParam *) 0;
 	type = ora_value->g_type;
 
-	if (type == GDA_TYPE_NULL)
+	if (type == G_TYPE_INVALID)
 		ora_value->indicator = -1;
 	else if ((type == G_TYPE_INT64) ||
 		 (type == G_TYPE_DOUBLE) ||
diff --git a/providers/postgres/gda-postgres-recordset.c b/providers/postgres/gda-postgres-recordset.c
index cc7d41e..22f3b32 100644
--- a/providers/postgres/gda-postgres-recordset.c
+++ b/providers/postgres/gda-postgres-recordset.c
@@ -271,7 +271,7 @@ finish_prep_stmt_init (PostgresConnectionData *cdata, GdaPostgresPStmt *ps, PGre
 		_GDA_PSTMT (ps)->tmpl_columns = g_slist_reverse (_GDA_PSTMT (ps)->tmpl_columns);
 
 		/* create prepared statement's types */
-		_GDA_PSTMT (ps)->types = g_new0 (GType, _GDA_PSTMT (ps)->ncols); /* all types are initialized to GDA_TYPE_NULL */
+		_GDA_PSTMT (ps)->types = g_new0 (GType, _GDA_PSTMT (ps)->ncols); /* all types are initialized to G_TYPE_INVALID */
 		if (col_types) {
 			for (i = 0; ; i++) {
 				if (col_types [i] > 0) {
diff --git a/providers/reuseable/gda-provider-reuseable.h b/providers/reuseable/gda-provider-reuseable.h
index e7a0606..529489d 100644
--- a/providers/reuseable/gda-provider-reuseable.h
+++ b/providers/reuseable/gda-provider-reuseable.h
@@ -46,7 +46,7 @@ typedef struct {
 	GdaProviderReuseable_NewDataFunc             re_new_data;
 	GdaProviderReuseable_ResetDataFunc           re_reset_data;
 
-	GdaProviderReuseable_GetGTypeFunc            re_get_type; /* Returns GDA_TYPE_NULL if conversion failed */
+	GdaProviderReuseable_GetGTypeFunc            re_get_type; /* Returns G_TYPE_INVALID if conversion failed */
 	GdaProviderReuseable_GetReservedKeywordsFunc re_get_reserved_keyword_func;
 
 	GdaProviderReuseable_CreateParserFunc        re_create_parser;
diff --git a/providers/reuseable/mysql/gda-mysql-reuseable.c b/providers/reuseable/mysql/gda-mysql-reuseable.c
index 4b9be8b..aab31d9 100644
--- a/providers/reuseable/mysql/gda-mysql-reuseable.c
+++ b/providers/reuseable/mysql/gda-mysql-reuseable.c
@@ -285,14 +285,14 @@ mysql_name_to_g_type (const gchar *name, const gchar *conv_func_name)
 		return GDA_TYPE_BLOB;
 	if (!strncmp (conv_func_name, "bytea", 5))
 		return GDA_TYPE_BINARY;
-	return GDA_TYPE_NULL;
+	return G_TYPE_INVALID;
 }
 
 GType
 _gda_mysql_reuseable_get_g_type (G_GNUC_UNUSED GdaConnection *cnc, G_GNUC_UNUSED GdaProviderReuseable *rdata,
 				 const gchar *db_type)
 {
-	g_return_val_if_fail (db_type, GDA_TYPE_NULL);
+	g_return_val_if_fail (db_type, G_TYPE_INVALID);
 
 	return mysql_name_to_g_type (db_type, NULL);
 }
diff --git a/providers/reuseable/postgres/gda-postgres-meta.c b/providers/reuseable/postgres/gda-postgres-meta.c
index aad3be3..ee1a5d6 100644
--- a/providers/reuseable/postgres/gda-postgres-meta.c
+++ b/providers/reuseable/postgres/gda-postgres-meta.c
@@ -2124,7 +2124,7 @@ concatenate_index_details (G_GNUC_UNUSED GdaServerProvider *prov, GdaConnection
 			return NULL;
 		}
 
-		if (G_VALUE_TYPE (value) == GDA_TYPE_NULL)
+		if (G_VALUE_TYPE (value) == G_TYPE_INVALID)
 			continue;
 		
 		/* get index's columns details */
diff --git a/providers/reuseable/postgres/gda-postgres-reuseable.c b/providers/reuseable/postgres/gda-postgres-reuseable.c
index 4d6c57c..71eba47 100644
--- a/providers/reuseable/postgres/gda-postgres-reuseable.c
+++ b/providers/reuseable/postgres/gda-postgres-reuseable.c
@@ -474,14 +474,14 @@ GType
 _gda_postgres_reuseable_get_g_type (GdaConnection *cnc, GdaProviderReuseable *rdata, const gchar *db_type)
 {
 	GdaPostgresTypeOid *type;
-	g_return_val_if_fail (db_type, GDA_TYPE_NULL);
+	g_return_val_if_fail (db_type, G_TYPE_INVALID);
 
 	_gda_postgres_compute_types (cnc, (GdaPostgresReuseable*)rdata);
 	type = g_hash_table_lookup (((GdaPostgresReuseable*)rdata)->types_dbtype_hash, db_type);
 	if (type)
 		return type->type;
 	else
-		return GDA_TYPE_NULL;
+		return G_TYPE_INVALID;
 }
 
 
diff --git a/providers/skel-implementation/capi/gda-capi-recordset.c b/providers/skel-implementation/capi/gda-capi-recordset.c
index 8cdfd54..810f1c0 100644
--- a/providers/skel-implementation/capi/gda-capi-recordset.c
+++ b/providers/skel-implementation/capi/gda-capi-recordset.c
@@ -170,7 +170,7 @@ gda_capi_recordset_new (GdaConnection *cnc, GdaCapiPStmt *ps, GdaSet *exec_param
 		_GDA_PSTMT (ps)->tmpl_columns = g_slist_reverse (_GDA_PSTMT (ps)->tmpl_columns);
 
 		/* create prepared statement's types */
-		_GDA_PSTMT (ps)->types = g_new0 (GType, _GDA_PSTMT (ps)->ncols); /* all types are initialized to GDA_TYPE_NULL */
+		_GDA_PSTMT (ps)->types = g_new0 (GType, _GDA_PSTMT (ps)->ncols); /* all types are initialized to G_TYPE_INVALID */
 		if (col_types) {
 			for (i = 0; ; i++) {
 				if (col_types [i] > 0) {
diff --git a/providers/web/gda-web-recordset.c b/providers/web/gda-web-recordset.c
index ecac236..02e6662 100644
--- a/providers/web/gda-web-recordset.c
+++ b/providers/web/gda-web-recordset.c
@@ -208,7 +208,7 @@ gda_web_recordset_new (GdaConnection *cnc, GdaWebPStmt *ps, GdaSet *exec_params,
 		_GDA_PSTMT (ps)->tmpl_columns = g_slist_reverse (_GDA_PSTMT (ps)->tmpl_columns);
 
 		/* create prepared statement's types */
-		_GDA_PSTMT (ps)->types = g_new0 (GType, _GDA_PSTMT (ps)->ncols); /* all types are initialized to GDA_TYPE_NULL */
+		_GDA_PSTMT (ps)->types = g_new0 (GType, _GDA_PSTMT (ps)->ncols); /* all types are initialized to G_TYPE_INVALID */
 		if (col_types) {
 			for (i = 0; ; i++) {
 				if (col_types [i] > 0) {
@@ -250,7 +250,7 @@ gda_web_recordset_new (GdaConnection *cnc, GdaWebPStmt *ps, GdaSet *exec_params,
 						GType type;
 						type = cdata->reuseable->operations->re_get_type (cnc, cdata->reuseable,
 												  (gchar*) prop);
-						if (type != GDA_TYPE_NULL) {
+						if (type != G_TYPE_INVALID) {
 							_GDA_PSTMT (ps)->types [i] = type;
 							gda_column_set_g_type (column, type);
 							typeset = TRUE;
diff --git a/tests/data-models/check_data_proxy.c b/tests/data-models/check_data_proxy.c
index 8aee2c3..9c4dd4c 100644
--- a/tests/data-models/check_data_proxy.c
+++ b/tests/data-models/check_data_proxy.c
@@ -160,7 +160,7 @@ validate_row_changes (GdaDataProxy *proxy, gint row, gint proxied_row, gchar *to
 	
 	cvalue = gda_data_model_get_value_at ((GdaDataModel*) proxy, 2, row, NULL);
 	g_assert (cvalue);
-	if (G_VALUE_TYPE (cvalue) == GDA_TYPE_NULL)
+	if (G_VALUE_TYPE (cvalue) == G_TYPE_INVALID)
 		return NULL;
 	else {
 		gint pop;
diff --git a/tests/data-models/check_pmodel.c b/tests/data-models/check_pmodel.c
index c343f59..f0843cf 100644
--- a/tests/data-models/check_pmodel.c
+++ b/tests/data-models/check_pmodel.c
@@ -1785,7 +1785,7 @@ test17 (GdaConnection *cnc)
 	for (i = 0, list = ((GdaSet*) iter)->holders;
 	     list;
 	     i++, list = list->next) {
-		if (gda_holder_get_g_type ((GdaHolder *) list->data) == GDA_TYPE_NULL) 
+		if (gda_holder_get_g_type ((GdaHolder *) list->data) == G_TYPE_INVALID) 
 			nullcol = i;
 		column = gda_data_model_describe_column (model, i);
 		if (gda_holder_get_g_type ((GdaHolder *) list->data) != 
diff --git a/tests/multi-threading/check_wrapper.c b/tests/multi-threading/check_wrapper.c
index 0658266..bb83773 100644
--- a/tests/multi-threading/check_wrapper.c
+++ b/tests/multi-threading/check_wrapper.c
@@ -504,7 +504,7 @@ wrapper_callback (GdaThreadWrapper *wrapper, gpointer instance, const gchar *sig
 	for (i = 0; i < n_param_values; i++) {
 		GValue *dest = ts->param_values + i;
 		const GValue *src = param_values + i;
-		if (G_VALUE_TYPE (src) != GDA_TYPE_NULL) {
+		if (G_VALUE_TYPE (src) != G_TYPE_INVALID) {
 			g_value_init (dest, G_VALUE_TYPE (src));
 			g_value_copy (src, dest);
 		}
diff --git a/tests/value-holders/check_holder.c b/tests/value-holders/check_holder.c
index d014131..3f83006 100644
--- a/tests/value-holders/check_holder.c
+++ b/tests/value-holders/check_holder.c
@@ -891,7 +891,7 @@ test11 (GError **error)
 	const GValue *cvalue;
 	GValue *value;
 
-	h = gda_holder_new (GDA_TYPE_NULL);
+	h = gda_holder_new (G_TYPE_INVALID);
 	emitted_signals_monitor_holder (h);
 
 	/***/
@@ -944,7 +944,7 @@ test12 (GError **error)
 	const GValue *cvalue;
 	GValue *value;
 
-	h = gda_holder_new (GDA_TYPE_NULL);
+	h = gda_holder_new (G_TYPE_INVALID);
 
 	/***/
 	value = gda_value_new_from_string ("my string", G_TYPE_STRING);
@@ -1006,8 +1006,8 @@ static gboolean
 test13 (GError **error)
 {
 	GdaHolder *h1, *h2;
-	h1 = gda_holder_new (GDA_TYPE_NULL);
-	h2 = gda_holder_new (GDA_TYPE_NULL);
+	h1 = gda_holder_new (G_TYPE_INVALID);
+	h2 = gda_holder_new (G_TYPE_INVALID);
 	if (! gda_holder_set_bind (h1, h2, error)) {
 		g_object_unref (h1);
 		g_object_unref (h2);
@@ -1025,7 +1025,7 @@ test13 (GError **error)
 	g_object_unref (h2);
 	
 	/* another test */
-	h1 = gda_holder_new (GDA_TYPE_NULL);
+	h1 = gda_holder_new (G_TYPE_INVALID);
 	h2 = gda_holder_new (G_TYPE_INT);
 	if (! gda_holder_set_bind (h1, h2, error)) {
 		g_object_unref (h1);
@@ -1044,7 +1044,7 @@ test13 (GError **error)
 
 	/* another test */
 	h1 = gda_holder_new (G_TYPE_STRING);
-	h2 = gda_holder_new (GDA_TYPE_NULL);
+	h2 = gda_holder_new (G_TYPE_INVALID);
 	if (! gda_holder_set_bind (h1, h2, error)) {
 		g_object_unref (h1);
 		g_object_unref (h2);
@@ -1070,7 +1070,7 @@ test13 (GError **error)
 
 	/* another test */
 	h1 = gda_holder_new (G_TYPE_STRING);
-	h2 = gda_holder_new (GDA_TYPE_NULL);
+	h2 = gda_holder_new (G_TYPE_INVALID);
 	if (! gda_holder_set_bind (h1, h2, error)) {
 		g_object_unref (h1);
 		g_object_unref (h2);
diff --git a/tools/browser/schema-browser/table-preferences.c b/tools/browser/schema-browser/table-preferences.c
index 92bd5e4..16d8b70 100644
--- a/tools/browser/schema-browser/table-preferences.c
+++ b/tools/browser/schema-browser/table-preferences.c
@@ -740,7 +740,7 @@ options_form_param_changed_cb (G_GNUC_UNUSED GdauiBasicForm *form, G_GNUC_UNUSED
 						continue;
 
 					cvalue = gda_holder_get_value (holder);
-					if (G_VALUE_TYPE (cvalue) == GDA_TYPE_NULL)
+					if (G_VALUE_TYPE (cvalue) == G_TYPE_INVALID)
 						continue;
 					if (first) {
 						g_string_append_c (plugin_all, ':');
@@ -813,7 +813,7 @@ set_preview_widget (TablePreferences *tpref)
 					if (gda_holder_is_valid (holder)) {
 						const GValue *cvalue;
 						cvalue = gda_holder_get_value (holder);
-						if (cvalue && (G_VALUE_TYPE (cvalue) != GDA_TYPE_NULL)) {
+						if (cvalue && (G_VALUE_TYPE (cvalue) != G_TYPE_INVALID)) {
 							gchar *str = gda_value_stringify (cvalue);
 							gchar *r1, *r2;
 							if (!string)
diff --git a/tools/gda-sql.c b/tools/gda-sql.c
index 5880760..0f363b8 100644
--- a/tools/gda-sql.c
+++ b/tools/gda-sql.c
@@ -1038,7 +1038,7 @@ execute_external_command (SqlConsole *console, const gchar *command, GError **er
 						goto cleanup;
 					}
 				}
-				else if (cvalue && (G_VALUE_TYPE (cvalue) == GDA_TYPE_NULL)) {
+				else if (cvalue && (G_VALUE_TYPE (cvalue) == G_TYPE_INVALID)) {
 					if (!gda_holder_set_value (h, cvalue, error)) {
 						g_free (res);
 						res = NULL;
diff --git a/tools/web-server.c b/tools/web-server.c
index 63f1aff..5b2078d 100644
--- a/tools/web-server.c
+++ b/tools/web-server.c
@@ -1355,7 +1355,7 @@ compute_trigger_content (HtmlDoc *hdoc, G_GNUC_UNUSED WebServer *webserver, cons
 			div = xmlNewChild (hdoc->content, NULL, BAD_CAST "div", NULL);
 		}
 
-		if (G_VALUE_TYPE (cv5) != GDA_TYPE_NULL)
+		if (G_VALUE_TYPE (cv5) != G_TYPE_INVALID)
 			tmp = g_strdup_printf ("On %s (%s):", g_value_get_string (cv2), g_value_get_string (cv5));
 		else
 			tmp = g_strdup_printf ("On %s:", g_value_get_string (cv2));
