/* * 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 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; }
/* * run_context_push * * Add a new run context level below @context, running @stmt to create a data model */ static RunContext * run_context_push_with_stmt (GdaReportEngine *engine, RunContext *context, GdaConnection *cnc, GdaStatement *stmt, const gchar *stmt_name, GError **error) { GdaDataModel *model; GdaSet *plist; GdaStatement *lstmt; lstmt = rewrite_statement (engine, context, stmt, error); if (!lstmt) return NULL; g_assert (cnc); if (!gda_statement_get_parameters (lstmt, &plist, error)) { g_object_unref (lstmt); return NULL; } if (plist && !assign_parameters_values (engine, context, plist, error)) { g_object_unref (plist); g_object_unref (lstmt); return NULL; } model = gda_connection_statement_execute_select (cnc, lstmt, plist, error); if (plist) g_object_unref (plist); g_object_unref (lstmt); if (!model) return NULL; g_object_set_data_full (G_OBJECT (model), "name", g_strdup (stmt_name), g_free); /* add a parameter for the number of rows, attached to model */ GdaHolder *param; GValue *value; gchar *name; param = gda_holder_new (G_TYPE_INT); value = gda_value_new (G_TYPE_INT); g_value_set_int (value, gda_data_model_get_n_rows (model)); if (! gda_holder_set_value (param, value, error)) { g_object_unref (param); gda_value_free (value); return NULL; } gda_value_free (value); name = g_strdup_printf ("%s|?nrows", stmt_name); g_object_set_data_full (G_OBJECT (model), name, param, g_object_unref); g_free (name); /* create a new RunContext */ RunContext *ctx; ctx = g_new0 (RunContext, 1); ctx->stmt = NULL; ctx->cnc = cnc; ctx->parent = context; ctx->model = model; ctx->iter = gda_data_model_create_iter (model); /*g_print (">>>> PUSH CONTEXT %p\n", ctx);*/ return ctx; }
static gboolean update_blob (GdaConnection *cnc, gint id, const gchar *data, glong binary_length, GError **error) { GdaStatement *stmt; GdaSet *plist; GdaHolder *param; GValue *value; gchar *str; gboolean retval; const gchar* SQL_UPDATE = "UPDATE blobs set name = ##/*name:'name' type:gchararray*/, data = ##/*name:'theblob' type:'GdaBlob'*/ WHERE id= ##/*name:'id' type:gint*/"; show_header ("Update a blob"); stmt = gda_sql_parser_parse_string (parser, SQL_UPDATE, NULL, error); if (!stmt) return FALSE; if (!gda_statement_get_parameters (stmt, &plist, NULL)) return FALSE; /* blob id */ param = gda_set_get_holder (plist, "id"); str = g_strdup_printf ("%d", id); if (! gda_holder_set_value_str (param, NULL, str, error)) return FALSE; g_free (str); /* blob name */ param = gda_set_get_holder (plist, "name"); str = g_strdup_printf ("BLOB_%d", id); if (! gda_holder_set_value_str (param, NULL, str, error)) return FALSE; g_free (str); /* blob data */ param = gda_set_get_holder (plist, "theblob"); value = gda_value_new_blob ((guchar*) data, binary_length); if (! gda_holder_set_value (param, value, error)) return FALSE; gda_value_free (value); gda_connection_clear_events_list (cnc); retval = exec_statement (cnc, stmt, plist, error); g_object_unref (stmt); g_object_unref (plist); return retval; }
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 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 GSList * gda_tree_mgr_columns_update_children (GdaTreeManager *manager, GdaTreeNode *node, G_GNUC_UNUSED const GSList *children_nodes, gboolean *out_error, GError **error) { GdaTreeMgrColumns *mgr = GDA_TREE_MGR_COLUMNS (manager); GdaMetaStore *store; GdaDataModel *model; GSList *list = NULL; GdaConnection *scnc; GdaTreeMgrColumnsPrivate *priv = gda_tree_mgr_columns_get_instance_private (mgr); if (!priv->cnc && !priv->mstore) { g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR, "%s", _("No connection and no GdaMetaStore specified")); if (out_error) *out_error = TRUE; return NULL; } else if (priv->mstore) store = priv->mstore; else store = gda_connection_get_meta_store (priv->cnc); scnc = gda_meta_store_get_internal_connection (store); /* create statements if necessary */ if (!priv->stmt) { GdaSqlParser *parser; GdaStatement *stmt; parser = gda_connection_create_parser (scnc); if (! parser) parser = gda_sql_parser_new (); stmt = gda_sql_parser_parse_string (parser, "SELECT column_name FROM _columns WHERE " "table_schema= ##schema::string AND " "table_name= ##table_name::string " "ORDER BY ordinal_position", NULL, error); g_object_unref (parser); if (!stmt) { if (out_error) *out_error = TRUE; return NULL; } if (!gda_statement_get_parameters (stmt, &(priv->params), error)) { if (out_error) *out_error = TRUE; g_object_unref (stmt); return NULL; } priv->stmt = stmt; } gboolean schema_specified = FALSE; gboolean table_specified = FALSE; if (priv->schema) { schema_specified = TRUE; g_assert (gda_set_set_holder_value (priv->params, NULL, "schema", priv->schema)); } if (priv->table_name) { table_specified = TRUE; g_assert (gda_set_set_holder_value (priv->params, NULL, "table_name", priv->table_name)); } if (!schema_specified && node) { /* looking for a schema in @node's attributes */ const GValue *cvalue; cvalue = gda_tree_node_fetch_attribute (node, "schema"); if (cvalue) { GdaHolder *h = gda_set_get_holder (priv->params, "schema"); if (!gda_holder_set_value (h, cvalue, error)) { if (out_error) *out_error = TRUE; return NULL; } schema_specified = TRUE; } } if (!table_specified && node) { /* looking for a table in @node's attributes */ const GValue *cvalue; cvalue = gda_tree_node_fetch_attribute (node, "table_name"); if (cvalue) { GdaHolder *h = gda_set_get_holder (priv->params, "table_name"); if (!gda_holder_set_value (h, cvalue, error)) { if (out_error) *out_error = TRUE; return NULL; } table_specified = TRUE; } } if (!schema_specified) { g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR, "%s", _("No schema specified")); if (out_error) *out_error = TRUE; return NULL; } if (!table_specified) { g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR, "%s", _("No table specified")); if (out_error) *out_error = TRUE; return NULL; } model = gda_connection_statement_execute_select (scnc, priv->stmt, 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; const GValue *cvalue; cvalue = gda_data_model_iter_get_value_at (iter, 0); if (!cvalue) { if (list) { g_slist_free_full (list, (GDestroyNotify) g_object_unref); } if (out_error) *out_error = TRUE; g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR, "%s", _("Unable to get column name")); return NULL; } snode = gda_tree_manager_create_node (manager, node, g_value_get_string (cvalue)); gda_tree_node_set_node_attribute (snode, "column_name", cvalue, NULL); list = g_slist_prepend (list, snode); } if (iter) g_object_unref (iter); g_object_unref (model); return list; }
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 gboolean do_test (ATest *test) { GdaSqlParser *parser; GdaStatement *stmt; GError *error = NULL; gchar *tmp; g_print ("** test %s\n", test->id); parser = gda_sql_parser_new (); GdaSet *params; GValue *nv; GdaHolder *holder; stmt = gda_sql_parser_parse_string (parser, test->sql, NULL, &error); g_object_unref (parser); if (!stmt) { g_print ("Parsing error: %s\n", error && error->message ? error->message : "No detail"); return FALSE; } if (! gda_statement_get_parameters (stmt, ¶ms, &error)) { g_print ("Error: %s\n", error && error->message ? error->message : "No detail"); return FALSE; } g_assert (gda_set_set_holder_value (params, NULL, "name", "zzz")); nv = gda_value_new_null (); holder = gda_set_get_holder (params, "id"); g_assert (gda_holder_set_value (holder, nv, NULL)); gda_value_free (nv); GdaSqlStatement *sqlst; g_object_get (stmt, "structure", &sqlst, NULL); sqlst = gda_rewrite_sql_statement_for_null_parameters (sqlst, params, NULL, &error); if (!sqlst) { g_print ("Rewrite error: %s\n", error && error->message ? error->message : "No detail"); return FALSE; } g_object_set (stmt, "structure", sqlst, NULL); /* SQL rendering */ tmp = gda_statement_to_sql_extended (stmt, NULL, NULL, GDA_STATEMENT_SQL_PARAMS_SHORT, NULL, &error); if (!tmp) { g_print ("Rendering error: %s\n", error && error->message ? error->message : "No detail"); return FALSE; } /*g_print ("SQL after mod: [%s]\n", tmp);*/ g_free (tmp); tmp = gda_sql_statement_serialize (sqlst); if (!tmp) { g_print ("Error: gda_sql_statement_serialize() failed\n"); return FALSE; } else if (strcmp (test->result, tmp)) { g_print ("Exp: [%s]\nGot: [%s]\n", test->result, tmp); return FALSE; } g_free (tmp); gda_sql_statement_free (sqlst); g_object_unref (stmt); 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; }