/* * 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 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 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); } }
GdaConnection * test_cnc_open_connection (const gchar *provider, const gchar *dbname, GError **error) { GdaConnection *cnc = NULL; gchar *str, *upname; const gchar *cnc_params; GdaProviderInfo *prov_info; GdaQuarkList *db_quark_list = NULL, *cnc_quark_list = NULL; gboolean db_created = FALSE; g_return_val_if_fail (dbname && *dbname, NULL); prov_info = gda_config_get_provider_info (provider); if (!prov_info) { g_set_error (error, TEST_ERROR, TEST_ERROR_GENERIC, "Provider '%s' not found", provider); return NULL; } /* open connection to database */ upname = prov_name_upcase (prov_info->id); str = g_strdup_printf ("%s_CNC_PARAMS", upname); cnc_params = getenv (str); g_free (str); if (cnc_params) cnc_quark_list = gda_quark_list_new_from_string (cnc_params); if (db_quark_list || cnc_quark_list) { Data1 data; data.string = g_string_new (""); data.ql = NULL; data.requested_db_name = NULL; if (db_quark_list) gda_quark_list_foreach (db_quark_list, (GHFunc) cnc_quark_foreach_func, &data); data.ql = db_quark_list; if (cnc_quark_list) gda_quark_list_foreach (cnc_quark_list, (GHFunc) cnc_quark_foreach_func, &data); if (*(data.string->str) != 0) g_string_append_c (data.string, ';'); g_string_append_printf (data.string, "DB_NAME=%s", data.requested_db_name ? data.requested_db_name : dbname); g_print ("Open connection string: %s\n", data.string->str); gchar *auth_string = NULL; GSList *current = prov_info->auth_params->holders; while (current) { GdaHolder *holder = (GdaHolder *) current->data; const gchar *id = gda_holder_get_id (holder); const gchar *env = NULL; if (g_strrstr (id, "USER") != NULL) { str = g_strdup_printf ("%s_USER", upname); env = getenv (str); g_free (str); } else if (g_strrstr (id, "PASS") != NULL) { str = g_strdup_printf ("%s_PASS", upname); env = getenv (str); g_free (str); } if (env) { str = g_strdup_printf ("%s=%s;", id, env); gchar *tmp = auth_string; auth_string = g_strconcat (auth_string, str, NULL); g_free (str); g_free (tmp); } current = g_slist_next (current); } cnc = gda_connection_open_from_string (prov_info->id, data.string->str, auth_string, GDA_CONNECTION_OPTIONS_NONE, error); g_free (auth_string); g_string_free (data.string, TRUE); } if (db_quark_list) gda_quark_list_free (db_quark_list); if (cnc_quark_list) gda_quark_list_free (cnc_quark_list); if (!cnc_params) g_set_error (error, TEST_ERROR, TEST_ERROR_GENERIC, "Connection parameters not specified, test not executed (define %s_CNC_PARAMS or %s_DBCREATE_PARAMS to create a test DB)\n", upname, upname); g_free (upname); return cnc; }
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 GSList * gda_tree_mgr_select_update_children (GdaTreeManager *manager, GdaTreeNode *node, G_GNUC_UNUSED const GSList *children_nodes, gboolean *out_error, GError **error) { GdaTreeMgrSelect *mgr = GDA_TREE_MGR_SELECT (manager); GdaDataModel *model; GSList *list = NULL; if (!mgr->priv->cnc) { g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR, "%s", _("No connection specified")); if (out_error) *out_error = TRUE; return NULL; } if (!mgr->priv->stmt) { g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR, "%s", _("No SELECT statement specified")); if (out_error) *out_error = TRUE; return NULL; } if (node && mgr->priv->non_bound_params) { /* looking for values in @node's attributes */ GSList *nbplist; for (nbplist = mgr->priv->non_bound_params; nbplist; nbplist = nbplist->next) { const GValue *cvalue; GdaHolder *holder = (GdaHolder*) nbplist->data; cvalue = gda_tree_node_fetch_attribute (node, gda_holder_get_id (holder)); if (cvalue) { if (!gda_holder_set_value (holder, cvalue, error)) { if (out_error) *out_error = TRUE; return NULL; } } else { g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR, _("No value specified for parameter '%s'"), gda_holder_get_id (holder)); if (out_error) *out_error = TRUE; return NULL; } } } model = gda_connection_statement_execute_select (mgr->priv->cnc, mgr->priv->stmt, mgr->priv->priv_params, error); if (!model) { if (out_error) *out_error = TRUE; return NULL; } GdaDataModelIter *iter; iter = gda_data_model_create_iter (model); for (; iter && gda_data_model_iter_move_next (iter);) { GdaTreeNode* snode = NULL; const GValue *cvalue; GSList *iholders; for (iholders = GDA_SET (iter)->holders; iholders; iholders = iholders->next) { GdaHolder *holder = (GdaHolder*) iholders->data; if (!gda_holder_is_valid (holder) || !(cvalue = gda_holder_get_value (holder))) { if (list) { g_slist_foreach (list, (GFunc) g_object_unref, NULL); g_slist_free (list); } if (out_error) *out_error = TRUE; g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR, "%s", _("Unable to get iterator's value")); return NULL; } if (!snode) { gchar *str = gda_value_stringify (cvalue); snode = gda_tree_manager_create_node (manager, node, str); g_free (str); list = g_slist_prepend (list, snode); } gda_tree_node_set_node_attribute (snode, g_strdup (gda_holder_get_id (holder)), cvalue, g_free); } } if (iter) g_object_unref (iter); g_object_unref (model); return list; }
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 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 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 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; } }
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; }
gchar * tests_common_holder_serialize (GdaHolder *h) { GString *string; gchar *str, *json; const GValue *value; string = g_string_new ("{"); g_string_append (string, "\"type\":"); g_string_append_printf (string, "\"%s\"", g_type_name (gda_holder_get_g_type (h))); g_string_append (string, ",\"id\":"); json = _json_quote_string (gda_holder_get_id (h)); g_string_append (string, json); g_free (json); g_object_get (G_OBJECT (h), "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 (h), "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); } g_string_append (string, ",\"value\":"); value = gda_holder_get_value (h); str = gda_value_stringify (value); json = _json_quote_string (str); g_free (str); g_string_append (string, json); g_free (json); g_string_append (string, ",\"default_value\":"); value = gda_holder_get_default_value (h); str = gda_value_stringify (value); json = _json_quote_string (str); g_free (str); g_string_append (string, json); g_free (json); g_string_append (string, ",\"is_default\":"); g_string_append_printf (string, gda_holder_value_is_default (h) ? "\"TRUE\"" : "\"FALSE\""); g_string_append (string, ",\"is_valid\":"); g_string_append_printf (string, gda_holder_is_valid (h) ? "\"TRUE\"" : "\"FALSE\""); g_string_append (string, ",\"not_null\":"); g_string_append_printf (string, gda_holder_get_not_null (h) ? "\"TRUE\"" : "\"FALSE\""); 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 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); }
/** * gda_batch_get_parameters: * @batch: a #GdaBatch object * @out_params: (out) (transfer full) (allow-none): a place to store a new #GdaSet object, or %NULL * @error: a place to store errors, or %NULL * * Get a new #GdaSet object which groups all the execution parameters * which @batch needs for all the statements it includes. * This new object is returned though @out_params. * * Note that if @batch does not need any parameter, then @out_params is set to %NULL. * * Returns: TRUE if no error occurred. */ gboolean gda_batch_get_parameters (GdaBatch *batch, GdaSet **out_params, GError **error) { GdaSet *set = NULL; GSList *list; g_return_val_if_fail (GDA_IS_BATCH (batch), FALSE); g_return_val_if_fail (batch->priv, FALSE); if (out_params) *out_params = NULL; if (!batch->priv->statements) return TRUE; for (list = batch->priv->statements; list; list = list->next) { GdaSet *tmpset = NULL; if (!gda_statement_get_parameters (GDA_STATEMENT (list->data), out_params ? &tmpset : NULL, error)) { if (tmpset) g_object_unref (tmpset); if (set) g_object_unref (set); return FALSE; } if (tmpset && tmpset->holders) { if (!set) { set = tmpset; tmpset = NULL; } else { /* merge @set and @tmp_set */ GSList *holders; for (holders = tmpset->holders; holders; holders = holders->next) { GdaHolder *holder = (GdaHolder *) holders->data; if (! gda_set_add_holder (set, holder)) { GdaHolder *eholder = gda_set_get_holder (set, gda_holder_get_id (holder)); if (!eholder || (gda_holder_get_g_type (eholder) != (gda_holder_get_g_type (holder)))) { /* error */ g_set_error (error, GDA_BATCH_ERROR, GDA_BATCH_CONFLICTING_PARAMETER_ERROR, _("Conflicting parameter '%s'"), gda_holder_get_id (holder)); g_object_unref (tmpset); g_object_unref (set); return FALSE; } } } } } if (tmpset) g_object_unref (tmpset); } if (set) { if (out_params) *out_params = set; else g_object_unref (set); } return TRUE; }