static gboolean
exec_statement (GdaConnection *cnc, GdaStatement *stmt, GdaSet *plist, GError **error)
{
GObject *exec_res;
exec_res = gda_connection_statement_execute (cnc, stmt, plist, GDA_STATEMENT_MODEL_RANDOM_ACCESS, NULL, error);
if (!exec_res)
return FALSE;
if (GDA_IS_DATA_MODEL (exec_res)) {
g_print ("Query returned a GdaDataModel...\n");
gda_data_model_dump ((GdaDataModel*) exec_res, stdout);
}
else {
if (GDA_IS_SET (exec_res)) {
GSList *list;
g_print ("Query returned a GdaSet:\n");
for (list = GDA_SET (exec_res)->holders; list; list = list->next) {
gchar *str;
str = gda_holder_get_value_str (GDA_HOLDER (list->data), NULL);
g_print (" %s => %s\n", gda_holder_get_id (GDA_HOLDER (list->data)), str);
g_free (str);
}
}
else
g_print ("Query returned a %s object\n", G_OBJECT_TYPE_NAME (exec_res));
}
return TRUE;
}
static GdaSet *
make_options_set_from_string (const gchar *context, GdaSet *options)
{
GdaSet *expopt = NULL;
GSList *list, *nlist = NULL;
if (options) {
for (list = options->holders; list; list = list->next) {
GdaHolder *param = GDA_HOLDER (list->data);
const GValue *cvalue;
cvalue = gda_holder_get_attribute (param, context);
if (!cvalue)
continue;
GdaHolder *nparam;
const GValue *cvalue2;
cvalue2 = gda_holder_get_value (param);
nparam = gda_holder_new (G_VALUE_TYPE (cvalue2));
g_object_set ((GObject*) nparam, "id", g_value_get_string (cvalue), NULL);
g_assert (gda_holder_set_value (nparam, cvalue2, NULL));
nlist = g_slist_append (nlist, nparam);
}
if (nlist) {
expopt = gda_set_new (nlist);
g_slist_free (nlist);
}
}
return expopt;
}
/*
* assign_parameters_values
*
* Tries to assign a value for each parameter in @plist, from the context
*
* Returns: TRUE on success
*/
static gboolean
assign_parameters_values (GdaReportEngine *engine, RunContext *context, GdaSet *plist, GError **error)
{
if (plist) {
GSList *list;
for (list = plist->holders; list; list = list->next) {
GdaHolder *source_param;
source_param = run_context_find_param (engine, context,
BAD_CAST gda_holder_get_id (GDA_HOLDER (list->data)));
if (!source_param) {
g_set_error (error, 0, 0,
_("Unknown parameter '%s'"),
gda_holder_get_id (GDA_HOLDER (list->data)));
return FALSE;
}
gda_holder_set_not_null (GDA_HOLDER (list->data), FALSE);
GType ptype, source_ptype;
ptype = gda_holder_get_g_type (GDA_HOLDER (list->data));
source_ptype = gda_holder_get_g_type (source_param);
if (ptype == source_ptype) {
if (! gda_holder_set_bind (GDA_HOLDER (list->data), source_param, error))
return FALSE;
}
else {
const GValue *source_value;
source_value = gda_holder_get_value (source_param);
if (source_value && !gda_value_is_null (source_value)) {
GValue *trans;
trans = gda_value_new (ptype);
if (g_value_transform (source_value, trans)) {
if (! gda_holder_set_value (GDA_HOLDER (list->data), trans, error)) {
gda_value_free (trans);
return FALSE;
}
gda_value_free (trans);
}
else {
gda_value_free (trans);
g_set_error (error, 0, 0,
_("Cannot cast parameter from type '%s' to type '%s'"),
g_type_name (source_ptype), g_type_name (ptype));
return FALSE;
}
}
else
if (! gda_holder_set_value (GDA_HOLDER (list->data), NULL, error))
return FALSE;
}
}
}
return TRUE;
}
static gchar *
params_to_string (GdauiProviderAuthEditor *auth)
{
GString *string = NULL;
gchar *str;
GdaSet *dset;
GSList *list;
g_assert (auth->priv->auth_widget);
if (! GDAUI_IS_BASIC_FORM (auth->priv->auth_widget))
return NULL;
dset = gdaui_basic_form_get_data_set (GDAUI_BASIC_FORM (auth->priv->auth_widget));
for (list = dset->holders; list; list = list->next) {
GdaHolder *param = GDA_HOLDER (list->data);
if (gda_holder_is_valid (param)) {
const GValue *value;
value = gda_holder_get_value (param);
str = NULL;
if (value && !gda_value_is_null ((GValue *) value)) {
GdaDataHandler *dh;
GType dtype;
dtype = gda_holder_get_g_type (param);
dh = gda_data_handler_get_default (dtype);
str = gda_data_handler_get_str_from_value (dh, value);
}
if (str && *str) {
gchar *name;
gchar *ename, *evalue;
if (!string)
string = g_string_new ("");
else
g_string_append_c (string, ';');
g_object_get (G_OBJECT (list->data), "id", &name, NULL);
ename = gda_rfc1738_encode (name);
evalue = gda_rfc1738_encode (str);
g_string_append_printf (string, "%s=%s", ename, evalue);
g_free (ename);
g_free (evalue);
}
g_free (str);
}
}
str = string ? string->str : NULL;
if (string)
g_string_free (string, FALSE);
return str;
}
static void
dump_iter (GdaDataModelIter *iter)
{
GdaSet *set;
GSList *list;
set = GDA_SET (iter);
g_print ("Dump of GdaDataModelIter %p, @row %d\n", set, gda_data_model_iter_get_row (iter));
for (list = set->holders; list; list = list->next) {
GdaHolder *h = GDA_HOLDER (list->data);
gchar *str;
const GValue *cvalue;
cvalue = gda_holder_get_value (h);
str = gda_value_stringify (cvalue);
g_print (" [%s] type: %s value:[%s]\n", gda_holder_get_id (h),
gda_g_type_to_string (gda_holder_get_g_type (h)), str);
g_free (str);
}
}
static void
options_form_param_changed_cb (G_GNUC_UNUSED GdauiBasicForm *form, G_GNUC_UNUSED GdaHolder *param,
G_GNUC_UNUSED gboolean is_user_modif, TablePreferences *tpref)
{
GtkTreeIter iter;
if (tpref->priv->save_plugin_changes &&
gtk_combo_box_get_active_iter (GTK_COMBO_BOX (tpref->priv->plugins_combo), &iter)) {
GdauiPlugin *plugin;
GError *error = NULL;
GString *plugin_all = NULL;
gtk_tree_model_get (tpref->priv->plugins_model, &iter, PL_COLUMN_PLUGIN, &plugin, -1);
if (plugin) {
plugin_all = g_string_new (plugin->plugin_name);
if (tpref->priv->options_wid) {
GdaSet *plist;
GSList *list;
gboolean first = TRUE;
plist = gdaui_basic_form_get_data_set (GDAUI_BASIC_FORM (tpref->priv->options_wid));
for (list = plist->holders; list; list = list->next) {
GdaHolder *holder;
const GValue *cvalue;
gchar *str, *r1, *r2;
holder = GDA_HOLDER (list->data);
if (! gda_holder_is_valid (holder))
continue;
cvalue = gda_holder_get_value (holder);
if (G_VALUE_TYPE (cvalue) == GDA_TYPE_NULL)
continue;
if (first) {
g_string_append_c (plugin_all, ':');
first = FALSE;
}
else
g_string_append_c (plugin_all, ';');
str = gda_value_stringify (cvalue);
r1 = gda_rfc1738_encode (str);
g_free (str);
r2 = gda_rfc1738_encode (gda_holder_get_id (holder));
g_string_append_printf (plugin_all, "%s=%s", r2, r1);
g_free (r1);
g_free (r2);
}
}
}
g_signal_handlers_block_by_func (tpref->priv->columns_store,
G_CALLBACK (columns_model_row_changed_cb), tpref);
if (tpref->priv->current_table &&
tpref->priv->current_column &&
! browser_connection_set_table_column_attribute (tpref->priv->bcnc,
tpref->priv->current_table,
tpref->priv->current_column,
BROWSER_CONNECTION_COLUMN_PLUGIN,
plugin_all ? plugin_all->str : NULL,
&error)) {
TO_IMPLEMENT; /* FIXME: add a notice somewhere in the UI */
g_warning ("Error: %s\n", error && error->message ? error->message : _("No detail"));
g_clear_error (&error);
}
g_signal_handlers_unblock_by_func (tpref->priv->columns_store,
G_CALLBACK (columns_model_row_changed_cb), tpref);
if (plugin_all)
g_string_free (plugin_all, TRUE);
}
set_preview_widget (tpref);
}
static void
set_preview_widget (TablePreferences *tpref)
{
GtkWidget *preview = NULL;
GtkTreeIter iter;
if (!tpref->priv->current_column)
return;
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (tpref->priv->plugins_combo), &iter)) {
GdauiPlugin *plugin;
GtkTreeModel *model;
GType gtype;
gtype = tpref->priv->current_column->gtype;
model = tpref->priv->plugins_model;
gtk_tree_model_get (model, &iter, PL_COLUMN_PLUGIN, &plugin, -1);
if (plugin) {
GString *string = NULL;
if (tpref->priv->options_wid) {
GdaSet *plist;
GSList *list;
plist = gdaui_basic_form_get_data_set (GDAUI_BASIC_FORM (tpref->priv->options_wid));
for (list = plist->holders; list; list = list->next) {
GdaHolder *holder;
holder = GDA_HOLDER (list->data);
if (gda_holder_is_valid (holder)) {
const GValue *cvalue;
cvalue = gda_holder_get_value (holder);
if (cvalue && (G_VALUE_TYPE (cvalue) != GDA_TYPE_NULL)) {
gchar *str = gda_value_stringify (cvalue);
gchar *r1, *r2;
if (!string)
string = g_string_new ("");
else
g_string_append_c (string, ';');
r1 = gda_rfc1738_encode (gda_holder_get_id (holder));
r2 = gda_rfc1738_encode (str);
g_free (str);
g_string_append_printf (string, "%s=%s", r1, r2);
g_free (r1);
g_free (r2);
}
}
}
}
if (string) {
g_string_prepend_c (string, ':');
g_string_prepend (string, plugin->plugin_name);
preview = GTK_WIDGET (gdaui_new_data_entry (gtype, string->str));
g_string_free (string, TRUE);
}
else
preview = GTK_WIDGET (gdaui_new_data_entry (gtype, plugin->plugin_name));
}
else
preview = GTK_WIDGET (gdaui_new_data_entry (gtype, NULL));
}
GValue *prev_value = NULL;
if (tpref->priv->preview_wid) {
prev_value = gdaui_data_entry_get_value (GDAUI_DATA_ENTRY (tpref->priv->preview_wid));
gtk_widget_destroy (tpref->priv->preview_wid);
gtk_widget_show (tpref->priv->preview_none);
tpref->priv->preview_wid = NULL;
}
if (preview) {
if (prev_value &&
(G_VALUE_TYPE (prev_value) == gdaui_data_entry_get_value_type (GDAUI_DATA_ENTRY (preview))))
gdaui_data_entry_set_value (GDAUI_DATA_ENTRY (preview), prev_value);
gdaui_data_entry_set_attributes (GDAUI_DATA_ENTRY (preview),
0, GDA_VALUE_ATTR_ACTIONS_SHOWN);
tpref->priv->preview_wid = preview;
gtk_box_pack_start (GTK_BOX (tpref->priv->preview_vbox), preview, TRUE, TRUE, 0);
gtk_widget_hide (tpref->priv->preview_none);
gtk_widget_show (tpref->priv->preview_wid);
}
if (prev_value)
gda_value_free (prev_value);
}
static void
selection_changed_cb (GtkTreeSelection *select, BrowserConnectionsList *clist)
{
GtkTreeModel *model;
GtkTreeIter iter;
BrowserConnection *bcnc = NULL;
const GdaDsnInfo *cncinfo = NULL;
if (gtk_tree_selection_get_selected (select, &model, &iter)) {
gtk_tree_model_get (model, &iter, COLUMN_BCNC, &bcnc, -1);
cncinfo = browser_connection_get_information (bcnc);
g_object_unref (bcnc);
gtk_widget_set_sensitive (_clist->priv->close_cnc_button, TRUE);
}
else
gtk_widget_set_sensitive (_clist->priv->close_cnc_button, FALSE);
if (clist->priv->cnc_params_editor) {
gtk_widget_destroy (clist->priv->cnc_params_editor);
clist->priv->cnc_params_editor = NULL;
}
if (cncinfo && cncinfo->provider) {
/* create GdaSet for parameters to display */
GdaSet *dset;
GdaHolder *holder;
dset = gda_set_new_inline (1, "PROVIDER_NAME", G_TYPE_STRING, cncinfo->provider);
holder = GDA_HOLDER (dset->holders->data);
g_object_set (G_OBJECT (holder), "name", _("Database provider"), NULL);
GdaProviderInfo *pinfo;
pinfo = gda_config_get_provider_info (cncinfo->provider);
if (pinfo && pinfo->dsn_params)
gda_set_merge_with_set (dset, pinfo->dsn_params);
holder = gda_holder_new_inline (G_TYPE_STRING, "GDA_BROWSER_DICT_FILE", _("In memory"));
g_object_set (G_OBJECT (holder),
"name", _("Dictionary file"),
"description", _("File used to store any information associated\n"
"to this connection (favorites, descriptions, ...)"), NULL);
gda_set_add_holder (dset, holder);
g_object_unref (holder);
if (bcnc) {
const gchar *dict_file_name;
dict_file_name = browser_connection_get_dictionary_file (bcnc);
if (dict_file_name)
gda_set_set_holder_value (dset, NULL, "GDA_BROWSER_DICT_FILE",
dict_file_name);
}
/* create form */
GtkWidget *wid;
wid = gdaui_basic_form_new (dset);
g_object_set ((GObject*) wid, "show-actions", FALSE, NULL);
gdaui_basic_form_entry_set_editable (GDAUI_BASIC_FORM (wid), NULL, FALSE);
gtk_grid_attach (clist->priv->layout_grid, wid, 1, 2, 1, 1);
gtk_widget_show (wid);
clist->priv->cnc_params_editor = wid;
/* fill GdaSet's parameters with values */
if (cncinfo->cnc_string) {
gchar **array = NULL;
array = g_strsplit (cncinfo->cnc_string, ";", 0);
if (array) {
gint index = 0;
gchar *tok;
gchar *value;
gchar *name;
for (index = 0; array[index]; index++) {
name = strtok_r (array [index], "=", &tok);
if (name)
value = strtok_r (NULL, "=", &tok);
else
value = NULL;
if (name && value) {
GdaHolder *param;
gda_rfc1738_decode (name);
gda_rfc1738_decode (value);
param = gda_set_get_holder (dset, name);
if (param)
g_assert (gda_holder_set_value_str (param, NULL, value, NULL));
}
}
g_strfreev (array);
}
}
g_object_unref (dset);
}
}
static void
plugins_combo_changed_cb (GtkComboBox *combo, TablePreferences *tpref)
{
GtkTreeIter iter;
GtkWidget *old_options = NULL;
if (tpref->priv->options_wid) {
old_options = tpref->priv->options_wid;
tpref->priv->options_wid = NULL;
}
if (gtk_combo_box_get_active_iter (combo, &iter)) {
GdauiPlugin *plugin;
GtkTreeModel *model;
GError *error = NULL;
model = gtk_combo_box_get_model (combo);
gtk_tree_model_get (model, &iter, PL_COLUMN_PLUGIN, &plugin, -1);
if (plugin && plugin->options_xml_spec) {
GdaSet *plist;
plist = gda_set_new_from_spec_string (plugin->options_xml_spec, &error);
if (!plist) {
g_warning ("Cannot parse XML spec for plugin options: %s",
error && error->message ? error->message : "No detail");
g_clear_error (&error);
}
else {
if (!old_options ||
(g_object_get_data (G_OBJECT (old_options), "plugin") != plugin)) {
tpref->priv->options_wid = gdaui_basic_form_new (plist);
g_object_set_data (G_OBJECT (tpref->priv->options_wid), "plugin", plugin);
g_signal_connect (G_OBJECT (tpref->priv->options_wid), "holder-changed",
G_CALLBACK (options_form_param_changed_cb), tpref);
gtk_box_pack_start (GTK_BOX (tpref->priv->options_vbox),
tpref->priv->options_wid, TRUE, TRUE, 0);
}
else {
tpref->priv->options_wid = old_options;
old_options = NULL;
}
g_object_unref (plist);
}
if (tpref->priv->options_wid) {
plist = gdaui_basic_form_get_data_set (GDAUI_BASIC_FORM (tpref->priv->options_wid));
gtk_widget_hide (tpref->priv->options_none);
gtk_widget_show (tpref->priv->options_wid);
if (plist && !tpref->priv->save_plugin_changes) {
/* load plugin options */
GtkTreeSelection *select;
GtkTreeIter citer;
select = gtk_tree_view_get_selection (tpref->priv->columns_treeview);
if (gtk_tree_selection_get_selected (select, NULL, &citer)) {
gchar *plugin_str;
gtk_tree_model_get (GTK_TREE_MODEL (tpref->priv->columns_store),
&citer, COLUMN_PLUGIN, &plugin_str, -1);
/*g_print ("%p PLUGIN_STR:[%s]\n", tpref, plugin_str);*/
if (plugin_str) {
GdaQuarkList *ql;
GSList *list;
gchar *tmp;
for (tmp = plugin_str; *tmp && (*tmp != ':'); tmp++);
if (*tmp == ':') {
ql = gda_quark_list_new_from_string (tmp+1);
for (list = plist->holders; list; list = list->next) {
GdaHolder *holder = GDA_HOLDER (list->data);
const gchar *cstr;
cstr = gda_quark_list_find (ql, gda_holder_get_id (holder));
if (cstr)
gda_holder_set_value_str (holder, NULL, cstr, NULL);
else
gda_holder_set_value (holder, NULL, NULL);
}
gda_quark_list_free (ql);
}
g_free (plugin_str);
}
}
}
}
}
if (tpref->priv->save_plugin_changes &&
tpref->priv->current_table &&
tpref->priv->current_column &&
! browser_connection_set_table_column_attribute (tpref->priv->bcnc,
tpref->priv->current_table,
tpref->priv->current_column,
BROWSER_CONNECTION_COLUMN_PLUGIN,
plugin ? plugin->plugin_name : NULL,
&error)) {
TO_IMPLEMENT; /* FIXME: add a notice somewhere in the UI */
g_warning ("Error: %s\n", error && error->message ? error->message : _("No detail"));
g_clear_error (&error);
}
set_preview_widget (tpref);
}
if (old_options)
gtk_widget_destroy (old_options);
if (! tpref->priv->options_wid)
gtk_widget_show (tpref->priv->options_none);
}
static gboolean
report_provider_status (GdaServerProvider *prov, GdaConnection *cnc)
{
gchar *header_str;
HtmlFile *file = config->index;
gboolean is_virt;
typedef void (*AFunc) (void);
typedef struct {
const gchar *name;
gboolean should_be;
void (*func) (void);
} ProvFunc;
GdaServerProviderClass *pclass;
if (prov && cnc && (prov != gda_connection_get_provider (cnc)))
/* ignoring connection as it has a different provider */
return TRUE;
g_assert (prov || cnc);
/* section */
if (cnc)
header_str = g_strdup_printf ("Report for connection '%s'", gda_connection_get_cnc_string (cnc));
else
header_str = g_strdup_printf ("Report for '%s' provider", gda_server_provider_get_name (prov));
/* provider info */
if (!prov)
prov = gda_connection_get_provider (cnc);
is_virt = GDA_IS_VIRTUAL_PROVIDER (prov);
pclass = (GdaServerProviderClass*) G_OBJECT_GET_CLASS (prov);
ProvFunc fa[] = {
{"get_name", TRUE, (AFunc) pclass->get_name},
{"get_version", TRUE, (AFunc) pclass->get_version},
{"get_server_version", TRUE, (AFunc) pclass->get_server_version},
{"supports_feature", TRUE, (AFunc) pclass->supports_feature},
{"get_data_handler", TRUE, (AFunc) pclass->get_data_handler},
{"get_def_dbms_type", TRUE, (AFunc) pclass->get_def_dbms_type},
{"escape_string", TRUE, (AFunc) pclass->escape_string},
{"unescape_string", TRUE, (AFunc) pclass->unescape_string},
{"open_connection", TRUE, (AFunc) pclass->open_connection},
{"close_connection", TRUE, (AFunc) pclass->close_connection},
{"supports_operation", is_virt ? FALSE : TRUE, (AFunc) pclass->supports_operation},
{"create_operation", FALSE, (AFunc) pclass->create_operation},
{"render_operation", FALSE, (AFunc) pclass->render_operation},
{"perform_operation", FALSE, (AFunc) pclass->perform_operation},
{"begin_transaction", FALSE, (AFunc) pclass->begin_transaction},
{"commit_transaction", FALSE, (AFunc) pclass->commit_transaction},
{"rollback_transaction", FALSE, (AFunc) pclass->rollback_transaction},
{"add_savepoint", FALSE, (AFunc) pclass->add_savepoint},
{"rollback_savepoint", FALSE, (AFunc) pclass->rollback_savepoint},
{"delete_savepoint", FALSE, (AFunc) pclass->delete_savepoint},
{"create_parser", FALSE, (AFunc) pclass->create_parser},
{"statement_to_sql", TRUE, (AFunc) pclass->statement_to_sql},
{"statement_prepare", TRUE, (AFunc) pclass->statement_prepare},
{"statement_execute", TRUE, (AFunc) pclass->statement_execute},
{"identifier_quote", TRUE, (AFunc) pclass->identifier_quote}
};
ProvFunc md[] = {
{"_info", TRUE, (AFunc) pclass->meta_funcs._info},
{"_btypes", TRUE, (AFunc) pclass->meta_funcs._btypes},
{"_udt", TRUE, (AFunc) pclass->meta_funcs._udt},
{"udt", TRUE, (AFunc) pclass->meta_funcs.udt},
{"_udt_cols", TRUE, (AFunc) pclass->meta_funcs._udt_cols},
{"udt_cols", TRUE, (AFunc) pclass->meta_funcs.udt_cols},
{"_enums", TRUE, (AFunc) pclass->meta_funcs._enums},
{"enums", TRUE, (AFunc) pclass->meta_funcs.enums},
{"_domains", TRUE, (AFunc) pclass->meta_funcs._domains},
{"domains", TRUE, (AFunc) pclass->meta_funcs.domains},
{"_constraints_dom", TRUE, (AFunc) pclass->meta_funcs._constraints_dom},
{"constraints_dom", TRUE, (AFunc) pclass->meta_funcs.constraints_dom},
{"_el_types", TRUE, (AFunc) pclass->meta_funcs._el_types},
{"el_types", TRUE, (AFunc) pclass->meta_funcs.el_types},
{"_collations", TRUE, (AFunc) pclass->meta_funcs._collations},
{"collations", TRUE, (AFunc) pclass->meta_funcs.collations},
{"_character_sets", TRUE, (AFunc) pclass->meta_funcs._character_sets},
{"character_sets", TRUE, (AFunc) pclass->meta_funcs.character_sets},
{"_schemata", TRUE, (AFunc) pclass->meta_funcs._schemata},
{"schemata", TRUE, (AFunc) pclass->meta_funcs.schemata},
{"_tables_views", TRUE, (AFunc) pclass->meta_funcs._tables_views},
{"tables_views", TRUE, (AFunc) pclass->meta_funcs.tables_views},
{"_columns", TRUE, (AFunc) pclass->meta_funcs._columns},
{"columns", TRUE, (AFunc) pclass->meta_funcs.columns},
{"_view_cols", TRUE, (AFunc) pclass->meta_funcs._view_cols},
{"view_cols", TRUE, (AFunc) pclass->meta_funcs.view_cols},
{"_constraints_tab", TRUE, (AFunc) pclass->meta_funcs._constraints_tab},
{"constraints_tab", TRUE, (AFunc) pclass->meta_funcs.constraints_tab},
{"_constraints_ref", TRUE, (AFunc) pclass->meta_funcs._constraints_ref},
{"constraints_ref", TRUE, (AFunc) pclass->meta_funcs.constraints_ref},
{"_key_columns", TRUE, (AFunc) pclass->meta_funcs._key_columns},
{"key_columns", TRUE, (AFunc) pclass->meta_funcs.key_columns},
{"_check_columns", TRUE, (AFunc) pclass->meta_funcs._check_columns},
{"check_columns", TRUE, (AFunc) pclass->meta_funcs.check_columns},
{"_triggers", TRUE, (AFunc) pclass->meta_funcs._triggers},
{"triggers", TRUE, (AFunc) pclass->meta_funcs.triggers},
{"_routines", TRUE, (AFunc) pclass->meta_funcs._routines},
{"routines", TRUE, (AFunc) pclass->meta_funcs.routines},
{"_routine_col", TRUE, (AFunc) pclass->meta_funcs._routine_col},
{"routine_col", TRUE, (AFunc) pclass->meta_funcs.routine_col},
{"_routine_par", TRUE, (AFunc) pclass->meta_funcs._routine_par},
{"routine_par", TRUE, (AFunc) pclass->meta_funcs.routine_par},
};
gboolean has_xa = gda_server_provider_supports_feature (prov, cnc,
GDA_CONNECTION_FEATURE_XA_TRANSACTIONS);
xmlNodePtr table, tr, td, span;
GdaSqlParser *parser;
GString *string;
gsize i;
GdaProviderInfo *pinfo;
pinfo = gda_config_get_provider_info (gda_server_provider_get_name (prov));
g_assert (pinfo);
table = xmlNewChild (file->body, NULL, BAD_CAST "table", NULL);
xmlSetProp (table, BAD_CAST "width", BAD_CAST "100%");
tr = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
td = xmlNewTextChild (tr, NULL, BAD_CAST "th", BAD_CAST header_str);
xmlSetProp (td, BAD_CAST "colspan", BAD_CAST "4");
/* line 1 */
tr = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Provider's name:");
td = xmlNewTextChild (tr, NULL, BAD_CAST "td", BAD_CAST gda_server_provider_get_name (prov));
xmlSetProp (td, BAD_CAST "width", (xmlChar*) "35%");
xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Provider is virtual:");
td = xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST (is_virt ? "Yes (uses the SQLite engine)" : "No"));
xmlSetProp (td, BAD_CAST "width", (xmlChar*) "35%");
/* line 2 */
tr = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Provider's version:");
xmlNewTextChild (tr, NULL, BAD_CAST "td", BAD_CAST gda_server_provider_get_version (prov));
xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Provider's server version:");
xmlNewTextChild (tr, NULL, BAD_CAST "td",
BAD_CAST (cnc ? gda_server_provider_get_server_version (prov, cnc) : "(non connected)"));
/* line 3 */
tr = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Provider's description:");
xmlNewTextChild (tr, NULL, BAD_CAST "td", BAD_CAST pinfo->description);
xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Filename:");
xmlNewTextChild (tr, NULL, BAD_CAST "td", BAD_CAST pinfo->location);
/* line 4 */
parser = gda_server_provider_create_parser (prov, cnc);
tr = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Creates its own SQL parser:");
xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST (parser ? "Yes" : "No"));
if (parser)
g_object_unref (parser);
xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Non implemented base methods:");
span = NULL;
td = xmlNewChild (tr, NULL, BAD_CAST "td", NULL);
for (i = 0; i < sizeof (fa) / sizeof (ProvFunc); i++) {
gchar *str;
ProvFunc *pf = &(fa[i]);
if (pf->func)
continue;
if (span)
str = g_strdup_printf (", %s()", pf->name);
else
str = g_strdup_printf ("%s()", pf->name);
span = xmlNewTextChild (td, NULL, BAD_CAST "span", BAD_CAST str);
g_free (str);
if (pf->should_be)
xmlSetProp (span, BAD_CAST "class", BAD_CAST "error");
}
if (!span)
xmlNodeSetContent (td, BAD_CAST "---");
/* line 5 */
tr = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Non implemented meta data methods:");
span = NULL;
td = xmlNewChild (tr, NULL, BAD_CAST "td", NULL);
for (i = 0; i < sizeof (md) / sizeof (ProvFunc); i++) {
gchar *str;
ProvFunc *pf = &(md[i]);
if (pf->func)
continue;
if (span)
str = g_strdup_printf (", %s()", pf->name);
else
str = g_strdup_printf ("%s()", pf->name);
span = xmlNewTextChild (td, NULL, BAD_CAST "span", BAD_CAST str);
g_free (str);
if (pf->should_be)
xmlSetProp (span, BAD_CAST "class", BAD_CAST "error");
}
if (!span)
xmlNodeSetContent (td, BAD_CAST "---");
xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Non implemented XA transactions:");
if (pclass->xa_funcs) {
if (!has_xa) {
td = xmlNewChild (tr, NULL, BAD_CAST "td",
BAD_CAST "The provider has the 'xa_funcs' part but "
"reports that distributed transactions are "
"not supported.");
xmlSetProp (td, BAD_CAST "class", BAD_CAST "warning");
}
else {
ProvFunc dt[] = {
{"xa_start", TRUE, (AFunc) pclass->xa_funcs->xa_start},
{"xa_end", FALSE, (AFunc) pclass->xa_funcs->xa_end},
{"xa_prepare", TRUE, (AFunc) pclass->xa_funcs->xa_prepare},
{"xa_commit", TRUE, (AFunc) pclass->xa_funcs->xa_commit},
{"xa_rollback", TRUE, (AFunc) pclass->xa_funcs->xa_rollback},
{"xa_recover", TRUE, (AFunc) pclass->xa_funcs->xa_recover},
};
span = NULL;
td = xmlNewChild (tr, NULL, BAD_CAST "td", NULL);
for (i = 0; i < sizeof (dt) / sizeof (ProvFunc); i++) {
gchar *str;
ProvFunc *pf = &(dt[i]);
if (pf->func)
continue;
if (span)
str = g_strdup_printf (", %s()", pf->name);
else
str = g_strdup_printf ("%s()", pf->name);
span = xmlNewTextChild (td, NULL, BAD_CAST "span", BAD_CAST str);
g_free (str);
if (pf->should_be)
xmlSetProp (span, BAD_CAST "class", BAD_CAST "error");
}
if (!span)
xmlNodeSetContent (td, BAD_CAST "---");
}
}
else {
if (has_xa) {
td = xmlNewTextChild (tr, NULL, BAD_CAST "td",
BAD_CAST "The provider does not have the 'xa_funcs' part but "
"reports that distributed transactions are "
"supported.");
xmlSetProp (td, BAD_CAST "class", BAD_CAST "warning");
}
else
xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "---");
}
/* line 6 */
tr = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Connection's parameters:");
if (pinfo->dsn_params && pinfo->dsn_params->holders) {
GSList *list;
td = xmlNewChild (tr, NULL, BAD_CAST "td", NULL);
for (list = pinfo->dsn_params->holders; list; list = list->next) {
gchar *str, *descr;
GdaHolder *holder = GDA_HOLDER (list->data);
g_object_get (G_OBJECT (holder), "description", &descr, NULL);
if (descr)
str = g_strdup_printf ("%s: %s", gda_holder_get_id (holder), descr);
else
str = g_strdup (gda_holder_get_id (holder));
g_free (descr);
xmlNewTextChild (td, NULL, BAD_CAST "div", BAD_CAST str);
g_free (str);
}
}
else {
td = xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "None provided");
xmlSetProp (td, BAD_CAST "class", BAD_CAST "error");
}
xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Authentication's parameters:");
if (pinfo->auth_params) {
GSList *list;
if (pinfo->auth_params->holders) {
td = xmlNewChild (tr, NULL, BAD_CAST "td", NULL);
for (list = pinfo->auth_params->holders; list; list = list->next) {
gchar *str, *descr;
GdaHolder *holder = GDA_HOLDER (list->data);
g_object_get (G_OBJECT (holder), "description", &descr, NULL);
if (descr)
str = g_strdup_printf ("%s: %s", gda_holder_get_id (holder), descr);
else
str = g_strdup (gda_holder_get_id (holder));
g_free (descr);
xmlNewTextChild (td, NULL, BAD_CAST "div", BAD_CAST str);
g_free (str);
}
}
else
td = xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "None required");
}
else {
td = xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "None provided");
xmlSetProp (td, BAD_CAST "class", BAD_CAST "error");
}
/* line 7 */
GdaConnectionFeature f;
string = NULL;
tr = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Supported features:");
for (f = 0; f < GDA_CONNECTION_FEATURE_LAST; f++) {
if (gda_server_provider_supports_feature (prov, cnc, f)) {
GEnumValue *ev;
ev = g_enum_get_value ((GEnumClass *) g_type_class_ref (GDA_TYPE_CONNECTION_FEATURE), f);
if (!string)
string = g_string_new (ev->value_name);
else
g_string_append_printf (string, ", %s", ev->value_name);
}
}
if (string) {
xmlNewTextChild (tr, NULL, BAD_CAST "td", BAD_CAST string->str);
g_string_free (string, TRUE);
}
else
xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "---");
string = NULL;
xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "Unsupported features:");
for (f = 0; f < GDA_CONNECTION_FEATURE_LAST; f++) {
if (!gda_server_provider_supports_feature (prov, cnc, f)) {
GEnumValue *ev;
ev = g_enum_get_value ((GEnumClass *) g_type_class_ref (GDA_TYPE_CONNECTION_FEATURE), f);
if (!string)
string = g_string_new (ev->value_name);
else
g_string_append_printf (string, ", %s", ev->value_name);
}
}
if (string) {
xmlNewTextChild (tr, NULL, BAD_CAST "td", BAD_CAST string->str);
g_string_free (string, TRUE);
}
else
xmlNewChild (tr, NULL, BAD_CAST "td", BAD_CAST "---");
g_free (header_str);
return TRUE;
}
static void
update_form_contents (GdauiProviderSpecEditor *spec)
{
/*g_print ("DSN: %s\n", spec->priv->cnc_string);*/
switch (spec->priv->type) {
case PROVIDER_FORM: {
/* update data set in form */
GdaSet *dset;
GSList *params_set = NULL;
GSList *list;
g_assert (spec->priv->form);
dset = gdaui_basic_form_get_data_set (GDAUI_BASIC_FORM (spec->priv->form));
/* split array in a list of named parameters, and for each parameter value, set the correcponding
parameter in @dset */
if (spec->priv->cnc_string) {
gchar **array = NULL;
array = g_strsplit (spec->priv->cnc_string, ";", 0);
if (array) {
gint index = 0;
gchar *tok;
gchar *value;
gchar *name;
for (index = 0; array[index]; index++) {
name = strtok_r (array [index], "=", &tok);
if (name)
value = strtok_r (NULL, "=", &tok);
else
value = NULL;
if (name && value) {
GdaHolder *param;
gda_rfc1738_decode (name);
gda_rfc1738_decode (value);
param = gda_set_get_holder (dset, name);
if (param)
if (gda_holder_set_value_str (param, NULL, value, NULL))
params_set = g_slist_prepend (params_set, param);
}
}
g_strfreev (array);
}
}
list = dset->holders;
while (0 && list) {
if (!params_set || !g_slist_find (params_set, list->data)) {
/* empty parameter */
gda_holder_set_value (GDA_HOLDER (list->data), NULL, NULL);
}
list = g_slist_next (list);
}
g_slist_free (params_set);
break;
}
default:
/* no change here */
break;
}
}
static void
gda_tree_mgr_select_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
GdaTreeMgrSelect *mgr;
mgr = GDA_TREE_MGR_SELECT (object);
if (mgr->priv) {
switch (param_id) {
case PROP_CNC:
mgr->priv->cnc = (GdaConnection*) g_value_get_object (value);
if (mgr->priv->cnc)
g_object_ref (mgr->priv->cnc);
break;
case PROP_STMT:
mgr->priv->stmt = (GdaStatement*) g_value_get_object (value);
if (mgr->priv->stmt) {
GError *lerror = NULL;
g_object_ref (mgr->priv->stmt);
if (!gda_statement_get_parameters (mgr->priv->stmt, &(mgr->priv->priv_params), &lerror)) {
g_warning (_("Could not get SELECT statement's parameters: %s"),
lerror && lerror->message ? lerror->message : _("No detail"));
if (lerror)
g_error_free (lerror);
}
if (mgr->priv->priv_params && mgr->priv->priv_params->holders)
mgr->priv->non_bound_params = g_slist_copy (mgr->priv->priv_params->holders);
}
break;
case PROP_PARAMS:
mgr->priv->params = (GdaSet*) g_value_get_object (value);
if (mgr->priv->params)
g_object_ref (mgr->priv->params);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
}
if (mgr->priv->priv_params && mgr->priv->params) {
/* bind holders in mgr->priv->priv_params to the ones in mgr->priv->params
* if they exist */
GSList *params;
GSList *non_bound_params = NULL;
g_slist_free (mgr->priv->non_bound_params);
for (params = mgr->priv->priv_params->holders; params; params = params->next) {
GdaHolder *frh = GDA_HOLDER (params->data);
GdaHolder *toh = gda_set_get_holder (mgr->priv->params, gda_holder_get_id (frh));
if (toh) {
GError *lerror = NULL;
if (!gda_holder_set_bind (frh, toh, &lerror)) {
g_warning (_("Could not bind SELECT statement's parameter '%s' "
"to provided parameters: %s"),
gda_holder_get_id (frh),
lerror && lerror->message ? lerror->message : _("No detail"));
if (lerror)
g_error_free (lerror);
non_bound_params = g_slist_prepend (non_bound_params, frh);
}
}
else
non_bound_params = g_slist_prepend (non_bound_params, frh);
}
mgr->priv->non_bound_params = non_bound_params;
}
}
static void
extract_named_parameters (GdaServerOperation *op, const gchar *root_path, GtkTextBuffer *tbuffer)
{
GdaServerOperationNode *node;
GtkTextIter iter;
gchar *str;
node = gda_server_operation_get_node_info (op, root_path);
g_return_if_fail (node);
gtk_text_buffer_get_end_iter (tbuffer, &iter);
gtk_text_buffer_insert (tbuffer, &iter, " * ", -1);
if (node->status == GDA_SERVER_OPERATION_STATUS_REQUIRED)
gtk_text_buffer_insert_with_tags_by_name (tbuffer, &iter, root_path, -1, "req_pathname", NULL);
else
gtk_text_buffer_insert_with_tags_by_name (tbuffer, &iter, root_path, -1, "opt_pathname", NULL);
gtk_text_buffer_insert (tbuffer, &iter, " (", -1);
switch (node->type) {
case GDA_SERVER_OPERATION_NODE_PARAMLIST: {
GSList *params;
str = g_strdup_printf ("GdaSet @%p)\n", node->plist);
gtk_text_buffer_insert (tbuffer, &iter, str, -1);
g_free (str);
for (params = node->plist->holders; params; params = params->next) {
gchar *npath;
npath = g_strdup_printf ("%s/%s", root_path, gda_holder_get_id (GDA_HOLDER (params->data)));
extract_named_parameters (op, npath, tbuffer);
g_free (npath);
}
break;
}
case GDA_SERVER_OPERATION_NODE_DATA_MODEL: {
gint i, ncols;
str = g_strdup_printf ("GdaDataModel @%p)\n", node->model);
gtk_text_buffer_insert (tbuffer, &iter, str, -1);
g_free (str);
ncols = gda_data_model_get_n_columns (node->model);
for (i = 0; i < ncols; i++) {
GdaColumn *col = gda_data_model_describe_column (node->model, i);
gchar *npath, *str;
g_object_get (G_OBJECT (col), "id", &str, NULL);
npath = g_strdup_printf ("%s/@%s", root_path, str);
g_free (str);
extract_named_parameters (op, npath, tbuffer);
g_free (npath);
}
break;
}
case GDA_SERVER_OPERATION_NODE_PARAM: {
gchar *str;
const GValue *value;
gtk_text_buffer_insert (tbuffer, &iter, "GdaHolder) = ", -1);
value = gda_holder_get_value (node->param);
str = gda_value_stringify (value);
gtk_text_buffer_insert (tbuffer, &iter, str, -1);
gtk_text_buffer_insert (tbuffer, &iter, "\n", -1);
g_free (str);
break;
}
case GDA_SERVER_OPERATION_NODE_SEQUENCE: {
gtk_text_buffer_insert (tbuffer, &iter, "Sequence)\n", -1);
guint i, size = gda_server_operation_get_sequence_size (op, root_path);
for (i = 0; i < size; i++) {
gchar **names;
names = gda_server_operation_get_sequence_item_names (op, root_path);
guint n;
for (n = 0; names [n]; n++) {
gchar *npath;
npath = g_strdup_printf ("%s/%u%s", root_path, i, names [n]);
extract_named_parameters (op, npath, tbuffer);
g_free (npath);
}
g_strfreev (names);
}
break;
}
case GDA_SERVER_OPERATION_NODE_SEQUENCE_ITEM:
gtk_text_buffer_insert (tbuffer, &iter, "Sequence item)\n", -1);
break;
case GDA_SERVER_OPERATION_NODE_DATA_MODEL_COLUMN: {
gint j, nrows;
gtk_text_buffer_insert (tbuffer, &iter, "Model column)\n", -1);
nrows = gda_data_model_get_n_rows (node->model);
for (j = 0; j < nrows; j++) {
gchar *npath, *str;
const GValue *value;
npath = g_strdup_printf ("%s/%d", root_path, j);
value = gda_data_model_get_value_at (node->model, gda_column_get_position (node->column), j, NULL);
if (value)
str = gda_value_stringify (value);
else
str = g_strdup ("Error: could not read data model's value");
gtk_text_buffer_insert (tbuffer, &iter, " * ", -1);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, &iter, npath, -1, "opt_pathname", NULL);
g_free (npath);
gtk_text_buffer_insert (tbuffer, &iter, " (GValue) = ", -1);
gtk_text_buffer_insert (tbuffer, &iter, str, -1);
gtk_text_buffer_insert (tbuffer, &iter, "\n", -1);
g_free (str);
}
break;
}
default:
gtk_text_buffer_insert (tbuffer, &iter, "???", -1);
break;
}
}
gchar *
tests_common_set_serialize (GdaSet *set)
{
GString *string;
gchar *str, *json;
GSList *list;
string = g_string_new ("{");
/* holders */
if (set->holders) {
g_string_append (string, "\"holders\":[");
for (list = set->holders; list; list = list->next) {
if (list != set->holders)
g_string_append_c (string, ',');
str = tests_common_holder_serialize (GDA_HOLDER (list->data));
g_string_append (string, str);
g_free (str);
}
g_string_append_c (string, ']');
}
/* set description */
g_object_get (G_OBJECT (set), "id", &str, NULL);
if (str) {
g_string_append (string, "\"id\":");
json = _json_quote_string (str);
g_string_append (string, json);
g_free (json);
g_free (str);
}
g_object_get (G_OBJECT (set), "name", &str, NULL);
if (str) {
g_string_append (string, ",\"name\":");
json = _json_quote_string (str);
g_string_append (string, json);
g_free (json);
g_free (str);
}
g_object_get (G_OBJECT (set), "description", &str, NULL);
if (str) {
g_string_append (string, ",\"descr\":");
json = _json_quote_string (str);
g_string_append (string, json);
g_free (json);
g_free (str);
}
/* public data */
if (set->nodes_list) {
g_string_append (string, ",\"nodes\":[");
for (list = set->nodes_list; list; list = list->next) {
GdaSetNode *node = (GdaSetNode*) list->data;
if (list != set->nodes_list)
g_string_append_c (string, ',');
g_string_append_c (string, '{');
g_string_append_printf (string, "\"holder\":%d", g_slist_index (set->holders, gda_set_node_get_holder (node)));
GdaDataModel *source_model;
source_model = gda_set_node_get_data_model (node);
if (source_model) {
g_string_append (string, ",\"source_model\":");
if (g_object_get_data (G_OBJECT (source_model), "name"))
json = _json_quote_string (g_object_get_data (G_OBJECT (source_model), "name"));
else {
str = gda_data_model_export_to_string (source_model,
GDA_DATA_MODEL_IO_TEXT_SEPARATED,
NULL, 0, NULL, 0, NULL);
json = _json_quote_string (str);
g_free (str);
}
g_string_append (string, json);
g_free (json);
g_string_append (string, ",\"source_column\":");
g_string_append_printf (string, "\"%d\"", gda_set_node_get_source_column (node));
/* FIXME: node->hint */
}
g_string_append_c (string, '}');
}
g_string_append_c (string, ']');
}
if (set->sources_list) {
g_string_append (string, ",\"sources\":[");
for (list = set->sources_list; list; list = list->next) {
GdaSetSource *source = (GdaSetSource*) list->data;
if (list != set->sources_list)
g_string_append_c (string, ',');
g_string_append_c (string, '{');
g_string_append (string, "\"model\":");
GdaDataModel *data_model;
data_model = gda_set_source_get_data_model (source);
if (g_object_get_data (G_OBJECT (data_model), "name"))
json = _json_quote_string (g_object_get_data (G_OBJECT (data_model), "name"));
else {
str = gda_data_model_export_to_string (data_model,
GDA_DATA_MODEL_IO_TEXT_SEPARATED,
NULL, 0, NULL, 0, NULL);
json = _json_quote_string (str);
g_free (str);
}
g_string_append (string, json);
g_free (json);
g_string_append (string, ",\"nodes\":[");
GSList *nodes;
for (nodes = gda_set_source_get_nodes (source); nodes; nodes = nodes->next) {
if (nodes != gda_set_source_get_nodes (source))
g_string_append_c (string, ',');
g_string_append_printf (string, "%d", g_slist_index (set->nodes_list, nodes->data));
}
g_string_append_c (string, ']');
g_string_append_c (string, '}');
}
g_string_append_c (string, ']');
}
g_string_append_c (string, '}');
str = string->str;
g_string_free (string, FALSE);
return str;
}
/**
* base_tool_output_result_to_string:
* @res: a #ToolCommandResult
* @format: a #ToolOutputFormat format specification
* @stream: (allow-none): a stream which the returned string will be put to, or %NULL
* @options: (allow-none): a #GdaSet containing options, or %NULL
*
* Converts @res to a string
*
* Returns: (transfer full): a new string
*/
gchar *
base_tool_output_result_to_string (ToolCommandResult *res, ToolOutputFormat format,
FILE *stream, GdaSet *options)
{
switch (res->type) {
case BASE_TOOL_COMMAND_RESULT_DATA_MODEL:
return base_tool_output_data_model_to_string (res->u.model, format, stream, options);
case BASE_TOOL_COMMAND_RESULT_SET: {
GSList *list;
GString *string;
xmlNodePtr node;
xmlBufferPtr buffer;
gchar *str;
if (format & BASE_TOOL_OUTPUT_FORMAT_DEFAULT) {
string = g_string_new ("");
for (list = res->u.set->holders; list; list = list->next) {
const GValue *value;
gchar *tmp;
const gchar *cstr;
GdaHolder *h;
h = GDA_HOLDER (list->data);
cstr = gda_holder_get_id (h);
value = gda_holder_get_value (h);
if (!strcmp (cstr, "IMPACTED_ROWS")) {
g_string_append_printf (string, "%s: ",
_("Number of rows impacted"));
tmp = gda_value_stringify (value);
g_string_append_printf (string, "%s", tmp);
g_free (tmp);
}
else if (!strcmp (cstr, "EXEC_DELAY")) {
g_string_append_printf (string, "%s: ",
_("Execution delay"));
gdouble etime;
etime = g_value_get_double (value);
g_string_append_printf (string, "%.03f s", etime);
}
else {
tmp = g_markup_escape_text (cstr, -1);
g_string_append_printf (string, "%s: ", tmp);
g_free (tmp);
tmp = gda_value_stringify (value);
g_string_append_printf (string, "%s", tmp);
g_free (tmp);
}
g_string_append (string, "\n");
}
str = string->str;
g_string_free (string, FALSE);
return str;
}
else if (format & BASE_TOOL_OUTPUT_FORMAT_XML) {
buffer = xmlBufferCreate ();
node = xmlNewNode (NULL, BAD_CAST "parameters");
for (list = res->u.set->holders; list; list = list->next) {
const GValue *value;
xmlNodePtr pnode, vnode;
pnode = xmlNewNode (NULL, BAD_CAST "parameter");
xmlAddChild (node, pnode);
xmlSetProp (pnode, BAD_CAST "name",
BAD_CAST gda_holder_get_id (GDA_HOLDER (list->data)));
value = gda_holder_get_value (GDA_HOLDER (list->data));
vnode = gda_value_to_xml (value);
xmlAddChild (pnode, vnode);
}
xmlNodeDump (buffer, NULL, node, 0, 1);
str = g_strdup ((gchar *) xmlBufferContent (buffer));
xmlBufferFree (buffer);
xmlFreeNode (node);
return str;
}
else if (format & BASE_TOOL_OUTPUT_FORMAT_HTML) {
buffer = xmlBufferCreate ();
node = xmlNewNode (NULL, BAD_CAST "ul");
for (list = res->u.set->holders; list; list = list->next) {
const GValue *value;
xmlNodePtr pnode, vnode;
pnode = xmlNewNode (NULL, BAD_CAST "li");
xmlAddChild (node, pnode);
xmlSetProp (pnode, BAD_CAST "name",
BAD_CAST gda_holder_get_id (GDA_HOLDER (list->data)));
value = gda_holder_get_value (GDA_HOLDER (list->data));
vnode = gda_value_to_xml (value);
xmlAddChild (pnode, vnode);
}
xmlNodeDump (buffer, NULL, node, 0, 1);
str = g_strdup ((gchar *) xmlBufferContent (buffer));
xmlBufferFree (buffer);
xmlFreeNode (node);
return str;
}
else if (format & BASE_TOOL_OUTPUT_FORMAT_CSV) {
string = g_string_new ("");
for (list = res->u.set->holders; list; list = list->next) {
const GValue *value;
gchar *tmp;
const gchar *cstr;
GdaHolder *h;
h = GDA_HOLDER (list->data);
cstr = gda_holder_get_id (h);
value = gda_holder_get_value (h);
if (!strcmp (cstr, "IMPACTED_ROWS")) {
g_string_append_printf (string, "\"%s\",",
_("Number of rows impacted"));
tmp = gda_value_stringify (value);
g_string_append_printf (string, "\"%s\"", tmp);
g_free (tmp);
}
else if (!strcmp (cstr, "EXEC_DELAY")) {
g_string_append_printf (string, "\"%s\",",
_("Execution delay"));
gdouble etime;
etime = g_value_get_double (value);
g_string_append_printf (string, "\"%.03f s\"", etime);
}
else {
tmp = g_markup_escape_text (cstr, -1);
g_string_append_printf (string, "\"%s\",", tmp);
g_free (tmp);
tmp = gda_value_stringify (value);
g_string_append_printf (string, "\"%s\"", tmp);
g_free (tmp);
}
g_string_append (string, "\n");
}
str = string->str;
g_string_free (string, FALSE);
return str;
}
else {
TO_IMPLEMENT;
return NULL;
}
}
case BASE_TOOL_COMMAND_RESULT_TREE: {
GdaSet *options2, *merge = NULL;
options2 = g_object_get_data ((GObject*) res->u.tree, "BASE_TOOL_OUTPUT_OPTIONS");
if (options && options2) {
merge = gda_set_copy (options2);
gda_set_merge_with_set (merge, options);
}
gchar *tmp;
tmp = tree_to_string (res->u.tree, format, stream, merge ? merge : (options ? options : options2));
if (merge)
g_object_unref (merge);
return tmp;
}
case BASE_TOOL_COMMAND_RESULT_TXT: {
xmlNodePtr node;
xmlBufferPtr buffer;
gchar *str;
if ((format & BASE_TOOL_OUTPUT_FORMAT_DEFAULT) ||
(format & BASE_TOOL_OUTPUT_FORMAT_CSV))
return g_strdup (res->u.txt->str);
else if (format & BASE_TOOL_OUTPUT_FORMAT_XML) {
buffer = xmlBufferCreate ();
node = xmlNewNode (NULL, BAD_CAST "txt");
xmlNodeSetContent (node, BAD_CAST res->u.txt->str);
xmlNodeDump (buffer, NULL, node, 0, 1);
str = g_strdup ((gchar *) xmlBufferContent (buffer));
xmlBufferFree (buffer);
xmlFreeNode (node);
return str;
}
else if (format & BASE_TOOL_OUTPUT_FORMAT_HTML) {
buffer = xmlBufferCreate ();
node = xmlNewNode (NULL, BAD_CAST "p");
xmlNodeSetContent (node, BAD_CAST res->u.txt->str);
xmlNodeDump (buffer, NULL, node, 0, 1);
str = g_strdup ((gchar *) xmlBufferContent (buffer));
xmlBufferFree (buffer);
xmlFreeNode (node);
return str;
}
else {
TO_IMPLEMENT;
return NULL;
}
}
case BASE_TOOL_COMMAND_RESULT_EMPTY:
return g_strdup ("");
case BASE_TOOL_COMMAND_RESULT_MULTIPLE: {
GSList *list;
GString *string = NULL;
gchar *str;
for (list = res->u.multiple_results; list; list = list->next) {
ToolCommandResult *tres = (ToolCommandResult*) list->data;
gchar *tmp;
tmp = base_tool_output_result_to_string (tres,
format & BASE_TOOL_OUTPUT_FORMAT_COLOR_TERM ? TRUE : FALSE,
stream, options);
if (!string)
string = g_string_new (tmp);
else {
g_string_append_c (string, '\n');
g_string_append (string, tmp);
}
g_free (tmp);
}
if (string) {
str = string->str;
g_string_free (string, FALSE);
}
else
str = g_strdup ("");
return str;
}
case BASE_TOOL_COMMAND_RESULT_HELP: {
if (format & BASE_TOOL_OUTPUT_FORMAT_XML) {
xmlBufferPtr buffer;
gchar *str;
buffer = xmlBufferCreate ();
xmlNodeDump (buffer, NULL, res->u.xml_node, 0, 1);
str = g_strdup ((gchar *) xmlBufferContent (buffer));
xmlBufferFree (buffer);
return str;
}
else if (format & BASE_TOOL_OUTPUT_FORMAT_HTML) {
TO_IMPLEMENT;
return NULL;
}
else {
gint width = -1;
gboolean term_color;
if (format & BASE_TOOL_OUTPUT_FORMAT_DEFAULT)
base_tool_input_get_size (&width, NULL);
term_color = format & BASE_TOOL_OUTPUT_FORMAT_COLOR_TERM ? TRUE : FALSE;
return base_tool_help_to_string (res, width, term_color);
}
break;
}
default:
g_assert_not_reached ();
return NULL;
}
}
/**
* gda_tools_favorites_get_actions
* @bfav: a #ToolsFavorites
* @bcnc: a #BrowserConnection
* @set: a #GdaSet
*
* Get a list of #ToolsFavoriteAction which can be executed with the data in @set.
*
* Returns: a new list of #ToolsFavoriteAction, free list with gda_tools_favorites_free_actions()
*/
GSList *
gda_tools_favorites_get_actions (ToolsFavorites *bfav, BrowserConnection *bcnc, GdaSet *set)
{
GSList *fav_list, *list, *retlist = NULL;
g_return_val_if_fail (GDA_TOOLS_IS_FAVORITES (bfav), NULL);
g_return_val_if_fail (BROWSER_IS_CONNECTION (bcnc), NULL);
g_return_val_if_fail (!set || GDA_IS_SET (set), NULL);
fav_list = gda_tools_favorites_list (bfav, 0, GDA_TOOLS_FAVORITES_ACTIONS, -1, NULL);
if (! fav_list)
return NULL;
for (list = fav_list; list; list = list->next) {
ToolsFavoritesAttributes *fa = (ToolsFavoritesAttributes*) list->data;
ToolsFavoritesAttributes qfa;
if (! g_str_has_prefix (fa->contents, "QUERY")) {
g_warning ("Malformed action contents '%s', please report error to "
"http://bugzilla.gnome.org/ for the \"libgda\" product",
fa->contents);
continue;
}
if (gda_tools_favorites_get (bfav, atoi (fa->contents + 5), &qfa, NULL)) {
GdaSet *params;
GSList *plist;
GdaBatch *batch;
GdaStatement *stmt = NULL;
GdaSqlParser *parser;
const gchar *remain;
const GSList *stmt_list;
gint nb_bound = 0;
parser = browser_connection_create_parser (bcnc);
batch = gda_sql_parser_parse_string_as_batch (parser, qfa.contents, &remain, NULL);
g_object_unref (parser);
if (!batch) {
gda_tools_favorites_reset_attributes (&qfa);
continue;
}
stmt_list = gda_batch_get_statements (batch);
for (plist = (GSList*) stmt_list; plist; plist = plist->next) {
if (! gda_statement_is_useless (GDA_STATEMENT (plist->data))) {
if (stmt)
break;
else
stmt = g_object_ref (GDA_STATEMENT (plist->data));
}
}
g_object_unref (batch);
if (!stmt || plist) {
gda_tools_favorites_reset_attributes (&qfa);
continue;
}
if (! gda_statement_get_parameters (stmt, ¶ms, NULL) || !params) {
g_object_unref (stmt);
gda_tools_favorites_reset_attributes (&qfa);
continue;
}
browser_connection_define_ui_plugins_for_stmt (bcnc, stmt, params);
for (plist = params->holders; plist; plist = plist->next) {
/* try to find holder in @set */
GdaHolder *req_holder, *in_holder;
req_holder = GDA_HOLDER (plist->data);
in_holder = gda_set_get_holder (set, gda_holder_get_id (req_holder));
if (in_holder && gda_holder_set_bind (req_holder, in_holder, NULL)) {
/* bound this holder to the oune found */
nb_bound++;
}
}
if (nb_bound > 0) {
/* at least 1 holder was found=> keep the action */
ToolsFavoriteAction *act;
act = g_new0 (ToolsFavoriteAction, 1);
retlist = g_slist_insert_sorted (retlist, act,
(GCompareFunc) actions_sort_func);
act->params = g_object_ref (params);
act->id = fa->id;
act->name = g_strdup (fa->name);
act->stmt = g_object_ref (stmt);
act->nb_bound = nb_bound;
/*g_print ("Action identified: ID=%d Bound=%d name=[%s] SQL=[%s]\n",
act->id, act->nb_bound,
act->name, qfa.contents);*/
}
g_object_unref (stmt);
g_object_unref (params);
gda_tools_favorites_reset_attributes (&qfa);
}
}
gda_tools_favorites_free_list (fav_list);
return retlist;
}
static void
form_grid_populate_popup_cb (GtkWidget *wid, GtkMenu *menu, UiFormGrid *formgrid)
{
/* add actions to execute to menu */
GdaDataModelIter *iter;
TConnection *tcnc = NULL;
tcnc = get_t_connection (formgrid);
if (!tcnc)
return;
iter = gdaui_data_selector_get_data_set (GDAUI_DATA_SELECTOR (formgrid->priv->raw_grid));
/* actions */
GSList *actions_list, *list;
actions_list = t_favorites_actions_get (t_connection_get_favorites (tcnc),
tcnc, GDA_SET (iter));
if (actions_list) {
GtkWidget *mitem, *submenu;
mitem = gtk_menu_item_new_with_label (_("Execute action"));
gtk_widget_show (mitem);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), mitem);
submenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (mitem), submenu);
for (list = actions_list; list; list = list->next) {
TFavoritesAction *act = (TFavoritesAction*) list->data;
mitem = gtk_menu_item_new_with_label (act->name);
gtk_widget_show (mitem);
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), mitem);
g_object_set_data_full (G_OBJECT (mitem), "action", act,
(GDestroyNotify) t_favorites_action_free);
g_signal_connect (mitem, "activate",
G_CALLBACK (execute_action_mitem_cb), formgrid);
}
g_slist_free (actions_list);
}
#ifdef HAVE_LDAP
/* LDAP specific */
if (t_connection_is_ldap (tcnc)) {
GdaHolder *dnh;
dnh = gda_set_get_holder (GDA_SET (iter), "dn");
if (dnh) {
const GValue *cvalue;
cvalue = gda_holder_get_value (GDA_HOLDER (dnh));
if (!cvalue && (G_VALUE_TYPE (cvalue) != G_TYPE_STRING))
dnh = NULL;
}
if (!dnh) {
GSList *list;
for (list = GDA_SET (iter)->holders; list; list = list->next) {
const GValue *cvalue;
cvalue = gda_holder_get_value (GDA_HOLDER (list->data));
if (cvalue && (G_VALUE_TYPE (cvalue) == G_TYPE_STRING) &&
gda_ldap_is_dn (g_value_get_string (cvalue))) {
dnh = GDA_HOLDER (list->data);
break;
}
}
}
if (dnh) {
const GValue *cvalue;
cvalue = gda_holder_get_value (dnh);
GtkWidget *mitem;
mitem = gtk_menu_item_new_with_label (_("View LDAP entry's details"));
gtk_widget_show (mitem);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), mitem);
g_object_set_data_full (G_OBJECT (mitem), "dn",
g_value_dup_string (cvalue), g_free);
g_signal_connect (mitem, "activate",
G_CALLBACK (ldap_view_dn_mitem_cb), formgrid);
}
}
#endif
if (wid == formgrid->priv->raw_form) {
GtkWidget *mitem;
gboolean add_scale;
g_object_get (G_OBJECT (formgrid->priv->overlay_form), "add-scale", &add_scale, NULL);
mitem = gtk_check_menu_item_new_with_label (_("Zoom..."));
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mitem), add_scale);
gtk_widget_show (mitem);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), mitem);
g_signal_connect (mitem, "toggled",
G_CALLBACK (zoom_form_mitem_cb), formgrid);
}
else if (wid == formgrid->priv->raw_grid) {
GtkWidget *mitem;
gboolean add_scale;
g_object_get (G_OBJECT (formgrid->priv->overlay_grid), "add-scale", &add_scale, NULL);
mitem = gtk_check_menu_item_new_with_label (_("Zoom..."));
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mitem), add_scale);
gtk_widget_show (mitem);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), mitem);
g_signal_connect (mitem, "toggled",
G_CALLBACK (zoom_grid_mitem_cb), formgrid);
}
}
static void
assistant_applied_cb (GtkAssistant *assist, G_GNUC_UNUSED gpointer data)
{
gboolean allok = TRUE;
GString *cnc_string = NULL;
GdauiDsnAssistant *assistant = (GdauiDsnAssistant *) assist;
g_return_if_fail (GDAUI_IS_DSN_ASSISTANT (assistant));
/* clear the internal dsn_info */
if (assistant->priv->dsn_info) {
data_source_info_free (assistant->priv->dsn_info);
assistant->priv->dsn_info = NULL;
}
/* New database creation first */
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (assistant->priv->choose_toggle))) {
if (!gda_server_operation_is_valid (assistant->priv->create_db_op, NULL, NULL)) {
_gdaui_utility_show_error (NULL, _("Missing mandatory information, to create database"));
gtk_assistant_set_current_page (assist, PAGE_CREATE_DB_INFO);
return;
}
else {
GdaProviderInfo *prov_info;
GSList *dsn_params;
GError *error = NULL;
allok = gda_server_operation_perform_create_database (assistant->priv->create_db_op, NULL, &error);
if (!allok) {
gchar *str;
str = g_strdup_printf (_("Error creating database: %s"),
error && error->message ? error->message : _("Unknown error"));
_gdaui_utility_show_error (NULL, str);
g_free (str);
gtk_assistant_set_current_page (assist, PAGE_CREATE_DB_INFO);
return;
}
/* make the connection string for the data source */
prov_info = gda_config_get_provider_info (gdaui_provider_selector_get_provider
(GDAUI_PROVIDER_SELECTOR (assistant->priv->general_provider)));
g_return_if_fail (prov_info);
for (dsn_params = prov_info->dsn_params->holders; dsn_params; dsn_params = dsn_params->next) {
GdaHolder *param = GDA_HOLDER (dsn_params->data);
const GValue *value;
value = gda_server_operation_get_value_at (assistant->priv->create_db_op,
"/DB_DEF_P/%s",
gda_holder_get_id (param));
if (!value)
value = gda_server_operation_get_value_at (assistant->priv->create_db_op,
"/SERVER_CNX_P/%s",
gda_holder_get_id (param));
if (value && !gda_value_is_null ((GValue *) value)) {
gchar *str;
if (dsn_params == prov_info->dsn_params->holders)
cnc_string = g_string_new ("");
else
g_string_append (cnc_string, ";");
str = gda_value_stringify ((GValue *) value);
g_string_append_printf (cnc_string, "%s=%s", gda_holder_get_id (param), str);
g_free (str);
}
}
}
}
/* Data source declaration */
if (allok) {
assistant->priv->dsn_info = g_new0 (GdaDsnInfo, 1);
assistant->priv->dsn_info->name = g_strdup (gtk_entry_get_text (GTK_ENTRY (assistant->priv->general_name)));
assistant->priv->dsn_info->provider = g_strdup (
gdaui_provider_selector_get_provider (
GDAUI_PROVIDER_SELECTOR (assistant->priv->general_provider)));
if (cnc_string) {
assistant->priv->dsn_info->cnc_string = cnc_string->str;
g_string_free (cnc_string, FALSE);
}
else
assistant->priv->dsn_info->cnc_string = _gdaui_provider_spec_editor_get_specs
(GDAUI_PROVIDER_SPEC_EDITOR (assistant->priv->provider_detail));
assistant->priv->dsn_info->description =
g_strdup (gtk_entry_get_text (GTK_ENTRY (assistant->priv->general_description)));
assistant->priv->dsn_info->auth_string = NULL;
if (assistant->priv->auth_detail)
assistant->priv->dsn_info->auth_string =
_gdaui_provider_auth_editor_get_auth (GDAUI_PROVIDER_AUTH_EDITOR (assistant->priv->auth_detail));
if (gda_config_can_modify_system_config ())
assistant->priv->dsn_info->is_system = gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (assistant->priv->general_is_system));
else
assistant->priv->dsn_info->is_system = FALSE;
}
/* notify listeners */
g_signal_emit (G_OBJECT (assistant), config_assistant_signals[FINISHED], 0, !allok);
}
static gboolean
compare_iter (GdaDataModelIter *iter, gint exp_row, const gchar **col_ids, const gchar **col_types,
const gchar **col_values)
{
GdaSet *set;
GSList *list;
gint i;
set = GDA_SET (iter);
if (gda_data_model_iter_get_row (iter) != exp_row) {
g_print ("Iter is at wrong row: got %d and expected %d\n",
gda_data_model_iter_get_row (iter), exp_row);
return FALSE;
}
if (!col_ids)
return TRUE;
for (i = 0, list = set->holders;
col_ids[i] && list;
i++, list = list->next) {
GdaHolder *h = GDA_HOLDER (list->data);
gchar *str;
const GValue *cvalue;
if (strcmp (col_ids[i], gda_holder_get_id (h))) {
g_print ("Wrong column %d ID: got [%s] and expected [%s]\n", i,
gda_holder_get_id (h), col_ids[i]);
return FALSE;
}
if (strcmp (col_types[i], gda_g_type_to_string (gda_holder_get_g_type (h)))) {
g_print ("Wrong column %d type: got [%s] and expected [%s]\n", i,
gda_g_type_to_string (gda_holder_get_g_type (h)),
col_types[i]);
return FALSE;
}
cvalue = gda_holder_get_value (h);
str = gda_value_stringify (cvalue);
if (strcmp (col_values[i], str)) {
g_print ("Wrong column %d value: got [%s] and expected [%s]\n", i,
str, col_values[i]);
g_free (str);
return FALSE;
}
g_free (str);
}
if (col_ids[i]) {
g_print ("Missing at least the [%s] column %d\n", col_ids[i], i);
return FALSE;
}
if (list) {
GdaHolder *h = GDA_HOLDER (list->data);
g_print ("Too much columns, at least [%s] column %d\n",
gda_holder_get_id (h), i);
return FALSE;
}
return TRUE;
}
/*
* Load data from file @file into table @table
*/
gboolean
test_cnc_load_data_from_file (GdaConnection *cnc, const gchar *table, const gchar *full_file, GError **error)
{
GdaStatement *stmt = NULL;
GdaSet *params = NULL;
GdaDataModel *import;
gint nrows, ncols, i;
GdaMetaStruct *mstruct = NULL;
GSList *list;
gboolean retval = TRUE;
/* loading XML file */
import = gda_data_model_import_new_file (full_file, TRUE, NULL);
if (gda_data_model_import_get_errors (GDA_DATA_MODEL_IMPORT (import))) {
g_set_error (error, TEST_ERROR, TEST_ERROR_GENERIC, "Error loading '%s' file", full_file);
return FALSE;
}
/* retrieving meta data info */
GdaMetaDbObject *table_dbo;
GValue *name_value;
g_value_set_string ((name_value = gda_value_new (G_TYPE_STRING)), table);
mstruct = gda_meta_struct_new (gda_connection_get_meta_store (cnc), GDA_META_STRUCT_FEATURE_NONE);
table_dbo = gda_meta_struct_complement (mstruct, GDA_META_DB_TABLE,
NULL, NULL, name_value, error);
gda_value_free (name_value);
if (! table_dbo) {
retval = FALSE;
goto out;
}
/* creating INSERT statement */
GdaSqlStatement *st;
GdaSqlStatementInsert *ist;
GSList *insert_values_list = NULL;
ist = g_new0 (GdaSqlStatementInsert, 1);
GDA_SQL_ANY_PART (ist)->type = GDA_SQL_ANY_STMT_INSERT;
ist->table = gda_sql_table_new (GDA_SQL_ANY_PART (ist));
ist->table->table_name = g_strdup (table);
GdaMetaTable *mtable = GDA_META_TABLE (table_dbo);
for (list = mtable->columns; list; list = list->next) {
GdaMetaTableColumn *tcol = GDA_META_TABLE_COLUMN (list->data);
GdaSqlField *field;
/* field */
field = gda_sql_field_new (GDA_SQL_ANY_PART (ist));
field->field_name = g_strdup (tcol->column_name);
ist->fields_list = g_slist_append (ist->fields_list, field);
/* value */
GdaSqlParamSpec *pspec = g_new0 (GdaSqlParamSpec, 1);
GdaSqlExpr *expr;
pspec->name = g_strdup (tcol->column_name);
pspec->g_type = tcol->gtype;
pspec->nullok = tcol->nullok;
expr = gda_sql_expr_new (GDA_SQL_ANY_PART (ist));
expr->param_spec = pspec;
insert_values_list = g_slist_append (insert_values_list, expr);
}
ist->values_list = g_slist_append (NULL, insert_values_list);
st = gda_sql_statement_new (GDA_SQL_STATEMENT_INSERT);
st->contents = ist;
stmt = g_object_new (GDA_TYPE_STATEMENT, "structure", st, NULL);
gda_sql_statement_free (st);
g_object_unref (mstruct);
if (! gda_statement_get_parameters (stmt, ¶ms, error)) {
retval = FALSE;
goto out;
}
/* executing inserts */
nrows = gda_data_model_get_n_rows (import);
ncols = gda_data_model_get_n_columns (import);
if (!gda_connection_begin_transaction (cnc, NULL, GDA_TRANSACTION_ISOLATION_UNKNOWN, error)) {
retval = FALSE;
goto out;
}
for (i = 0; i < nrows; i++) {
gint j;
GSList *list;
for (list = params->holders, j = 0; list && (j < ncols); list = list->next, j++) {
const GValue *cvalue = gda_data_model_get_value_at (import, j, i, error);
if (!cvalue) {
gda_connection_rollback_transaction (cnc, NULL, NULL);
retval = FALSE;
goto out;
}
if (! gda_holder_set_value (GDA_HOLDER (list->data), cvalue, error)) {
gda_connection_rollback_transaction (cnc, NULL, NULL);
retval = FALSE;
goto out;
}
}
if (list || (j < ncols)) {
g_set_error (error, TEST_ERROR, TEST_ERROR_GENERIC, "%s",
"Incoherent number of columns in table and imported data");
gda_connection_rollback_transaction (cnc, NULL, NULL);
retval = FALSE;
goto out;
}
if (gda_connection_statement_execute_non_select (cnc, stmt, params, NULL, error) == -1) {
gda_connection_rollback_transaction (cnc, NULL, NULL);
retval = FALSE;
goto out;
}
}
if (! gda_connection_commit_transaction (cnc, NULL, error))
retval = FALSE;
out:
if (import)
g_object_unref (import);
if (stmt)
g_object_unref (stmt);
if (params)
g_object_unref (params);
return retval;
}
