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; }