static void
__initialize_statement_delete_query_parameters (MidgardDBObjectClass *klass, const gchar *query_string, gboolean add_workspace)
{
GdaSqlParser *parser = gda_sql_parser_new ();
GdaStatement *stmt;
GError *error = NULL;
stmt = gda_sql_parser_parse_string (parser, query_string, NULL, &error);
if (!stmt) {
g_error ("Couldn't create %s class DELETE(UPDATE) prepared statement. %s",
G_OBJECT_CLASS_NAME (klass), error && error->message ? error->message : "Unknown reason");
return;
}
GdaSet *params;
if (!gda_statement_get_parameters (stmt, ¶ms, &error)) {
g_error ("Failed to create DELETE(UPDATE) GdaSet for %s class. %s",
G_OBJECT_CLASS_NAME (klass), error && error->message ? error->message : "Unknown reason");
}
if (add_workspace) {
klass->dbpriv->_workspace_statement_delete = stmt;
klass->dbpriv->_workspace_statement_delete_params = params;
return;
}
klass->dbpriv->_statement_delete = stmt;
klass->dbpriv->_statement_delete_params = params;
return;
}
/**
* gda_repetitive_statement_get_template_set:
* @rstmt: a #GdaRepetitiveStatement object
* @set: a place to store the returned template set
* @error: (nullable): a place to store error, or %NULL
*
* Gets a new #GdaSet object with the parameters used by the template statement in the
* @rstmt object.
*
* Use this object with gda_repetitive_statement_append_set().
*
* Returns: %TRUE on success, %FALSE on error
*
* Since: 4.2
*/
gboolean
gda_repetitive_statement_get_template_set (GdaRepetitiveStatement *rstmt, GdaSet **set, GError **error)
{
GdaRepetitiveStatementPrivate *priv = gda_repetitive_statement_get_instance_private (rstmt);
return gda_statement_get_parameters (priv->statement, set, error);
}
/*
* 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;
}
/*
* get_parameters()
*/
static gboolean
test1 (GError **error)
{
GdaSqlParser *parser;
guint i;
parser = gda_sql_parser_new ();
for (i = 0; i < sizeof (test1_data) / sizeof (ATest); i++) {
ATest *test = &(test1_data[i]);
GdaStatement *stmt;
GError *lerror = NULL;
stmt = gda_sql_parser_parse_string (parser, test->sql, NULL, &lerror);
if (!stmt) {
if (test->result) {
if (lerror)
g_propagate_error (error, lerror);
return FALSE;
}
}
else {
GdaSet *set;
if (!gda_statement_get_parameters (stmt, &set, &lerror)) {
if (test->result) {
if (lerror)
g_propagate_error (error, lerror);
return FALSE;
}
}
else if (set) {
if (!tests_common_check_set (data, test->id, set, &lerror)) {
if (lerror)
g_propagate_error (error, lerror);
return FALSE;
}
g_object_unref (set);
}
g_object_unref (stmt);
}
if (lerror)
g_error_free (lerror);
}
g_object_unref (parser);
return TRUE;
}
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;
}
/*
* ... is a list of (const gchar *name, const gchar *value) couples, terminated by %NULL
*/
static guint
request_execution_with_params (GdaConnection *cnc, const gchar *sql, ...)
{
GdaStatement *stmt;
guint id;
GError *error = NULL;
GdaSet *params;
const gchar *pname;
g_print ("=========== Async. exececution request:\n%s\n", sql);
stmt = create_statement (sql);
if (! gda_statement_get_parameters (stmt, ¶ms, &error)) {
g_print ("Can't get statement's parameters: %s\n", error && error->message ? error->message : "No detail");
exit (1);
}
if (params) {
va_list ap;
va_start (ap, sql);
for (pname = va_arg (ap, const gchar *); pname; pname = va_arg (ap, const gchar *)) {
const gchar *value;
GdaHolder *holder;
holder = gda_set_get_holder (params, pname);
value = va_arg (ap, const gchar *);
if (holder)
g_assert (gda_holder_set_value_str (holder, NULL, value, NULL));
g_print ("\t%s => %s\n", pname, value);
va_end (ap);
}
}
id = gda_connection_async_statement_execute (cnc, stmt, params, GDA_STATEMENT_MODEL_RANDOM_ACCESS, NULL, FALSE,
&error);
if (params)
g_object_unref (params);
g_object_unref (stmt);
if (id == 0) {
g_print ("Can't execute ASYNC: %s\n", error && error->message ? error->message : "No detail");
exit (1);
}
g_print ("Assigned task id: %u\n", id);
return id;
}
/*
* evaluate_expression
*
* Evaluates the @expr expression, which must be a valid SQLite expression
*
* Returns: a new GValue if no error occurred
*/
static GValue *
evaluate_expression (GdaReportEngine *engine, RunContext *context, const gchar *expr, GError **error)
{
GdaStatement *stmt;
GdaSet *plist;
GdaDataModel *model;
GValue *retval;
gchar *sql;
static GMutex init_mutex;
GdaConnection *vcnc = NULL;
GdaSqlParser *parser;
/* create a virtual connection to execute the expression, if it's the first time */
g_mutex_lock (&init_mutex);
if (!vcnc) {
static GdaVirtualProvider *provider = NULL;
if (!provider)
provider = gda_vprovider_data_model_new ();
vcnc = gda_virtual_connection_open (provider, GDA_CONNECTION_OPTIONS_NONE, error);
if (! vcnc) {
g_mutex_unlock (&init_mutex);
return NULL;
}
}
g_mutex_unlock (&init_mutex);
/* parser */
parser = g_object_get_data (G_OBJECT (context->cnc), "__gda_parser");
if (!parser) {
parser = gda_connection_create_parser (context->cnc);
g_object_set_data_full (G_OBJECT (context->cnc), "__gda_parser",
parser, g_object_unref);
}
/* create the stmt
* REM: SQL injection is prevented because only the first statement is kept by GdaStatement
*/
sql = g_strdup_printf ("SELECT %s", expr);
stmt = gda_sql_parser_parse_string (parser, sql, NULL, error);
if (!stmt)
return NULL;
GdaStatement *lstmt;
lstmt = rewrite_statement (engine, context, stmt, error);
g_object_unref (stmt);
if (!lstmt)
return NULL;
stmt = lstmt;
if (!gda_statement_get_parameters (stmt, &plist, error)) {
g_object_unref (stmt);
return NULL;
}
if (plist) {
if (!assign_parameters_values (engine, context, plist, error)) {
g_object_unref (stmt);
g_object_unref (plist);
return NULL;
}
}
model = gda_connection_statement_execute_select (vcnc, stmt, plist, error);
if (plist)
g_object_unref (plist);
g_object_unref (stmt);
if (!model)
return NULL;
if (gda_data_model_get_n_rows (model) != 1) {
g_set_error (error, 0, 0,
_("Expression '%s' should return exactly one value"), expr);
return NULL;
}
retval = (GValue *) gda_data_model_get_value_at (model, 0, 0, error);
if (retval)
retval = gda_value_copy (retval);
g_object_unref (model);
return retval;
}
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_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;
}
/*
* @prov may be NULL
*/
static guint
do_a_test (GdaServerProvider *prov, GdaSqlParser *parser)
{
guint nfailed = 0;
GdaStatement *stmt;
GdaSet *params;
gchar *sql;
GError *error = NULL;
/* SQL parsed as an INSERT statement */
sql = "INSERT INTO tstest VALUES (##ts::timestamp, ##time::time)";
stmt = gda_sql_parser_parse_string (parser, sql, NULL, &error);
if (!stmt) {
g_print ("Failed to parse [%s]: %s\n", sql, error && error->message ? error->message : "No detail");
g_clear_error (&error);
nfailed ++;
goto endtest;
}
g_assert (gda_statement_get_statement_type (stmt) == GDA_SQL_STATEMENT_INSERT);
if (! gda_statement_get_parameters (stmt, ¶ms, &error)) {
g_print ("Failed to obtain parameters: %s\n", error && error->message ? error->message : "No detail");
g_clear_error (&error);
g_object_unref (stmt);
nfailed ++;
goto endtest;
}
if (! gda_set_set_holder_value (params, &error, "ts", &ts)) {
g_print ("Failed to bind 'ts' parameter: %s\n", error && error->message ? error->message : "No detail");
g_clear_error (&error);
g_object_unref (stmt);
g_object_unref (params);
nfailed ++;
goto endtest;
}
if (! gda_set_set_holder_value (params, &error, "time", >)) {
g_print ("Failed to bind 'time' parameter: %s\n", error && error->message ? error->message : "No detail");
g_clear_error (&error);
g_object_unref (stmt);
g_object_unref (params);
nfailed ++;
goto endtest;
}
GdaConnection *cnc = NULL;
if (prov) {
cnc = gda_connection_new_from_string (gda_server_provider_get_name (prov), "DB_NAME=dummy;HOST=dummy", NULL,
GDA_CONNECTION_OPTIONS_NONE, &error);
if (!cnc) {
g_print ("Failed to create GdaConnection object: %s\n",
error && error->message ? error->message : "No detail");
g_clear_error (&error);
g_object_unref (stmt);
g_object_unref (params);
nfailed ++;
goto endtest;
}
}
gchar *expected;
expected = "('@@@@@@@@@@ 17:10:23+2', '16:09:22-3')";
if (cnc)
sql = gda_connection_statement_to_sql (cnc, stmt, params, 0, NULL, &error);
else
sql = gda_statement_to_sql_extended (stmt, NULL, params, 0, NULL, &error);
if (!sql) {
g_print ("Failed to render as SQL: %s\n", error && error->message ? error->message : "No detail");
g_clear_error (&error);
g_object_unref (stmt);
g_object_unref (params);
nfailed ++;
goto endtest;
}
if (!string_equal_to_template (sql, expected)) {
g_print ("Wrong rendered SQL: [%s] instead of [%s]\n", sql, expected);
g_object_unref (stmt);
g_object_unref (params);
g_free (sql);
nfailed ++;
goto endtest;
}
g_free (sql);
expected = "('@@@@@@@@@@ 15:10:23', '19:09:22')";
if (cnc)
sql = gda_connection_statement_to_sql (cnc, stmt, params, GDA_STATEMENT_SQL_TIMEZONE_TO_GMT, NULL, &error);
else
sql = gda_statement_to_sql_extended (stmt, NULL, params, GDA_STATEMENT_SQL_TIMEZONE_TO_GMT, NULL, &error);
if (!sql) {
g_print ("Failed to render as SQL: %s\n", error && error->message ? error->message : "No detail");
g_clear_error (&error);
g_object_unref (stmt);
g_object_unref (params);
nfailed ++;
goto endtest;
}
if (!string_equal_to_template (sql, expected)) {
g_print ("Wrong rendered SQL for GMT timezone: [%s] instead of [%s]\n", sql, expected);
g_object_unref (stmt);
g_object_unref (params);
g_free (sql);
nfailed ++;
goto endtest;
}
g_free (sql);
/* SQL not parsed as a valid statement */
sql = "AAAA (##ts::timestamp, ##time::time)";
stmt = gda_sql_parser_parse_string (parser, sql, NULL, &error);
if (!stmt) {
g_print ("Failed to parse [%s]: %s\n", sql, error && error->message ? error->message : "No detail");
g_clear_error (&error);
nfailed ++;
goto endtest;
}
g_assert (gda_statement_get_statement_type (stmt) == GDA_SQL_STATEMENT_UNKNOWN);
if (! gda_statement_get_parameters (stmt, ¶ms, &error)) {
g_print ("Failed to obtain parameters: %s\n", error && error->message ? error->message : "No detail");
g_clear_error (&error);
g_object_unref (stmt);
nfailed ++;
goto endtest;
}
if (! gda_set_set_holder_value (params, &error, "ts", &ts)) {
g_print ("Failed to bind 'ts' parameter: %s\n", error && error->message ? error->message : "No detail");
g_clear_error (&error);
g_object_unref (stmt);
g_object_unref (params);
nfailed ++;
goto endtest;
}
if (! gda_set_set_holder_value (params, &error, "time", >)) {
g_print ("Failed to bind 'time' parameter: %s\n", error && error->message ? error->message : "No detail");
g_clear_error (&error);
g_object_unref (stmt);
g_object_unref (params);
nfailed ++;
goto endtest;
}
expected = "('@@@@@@@@@@ 17:10:23+2', '16:09:22-3')";
if (cnc)
sql = gda_connection_statement_to_sql (cnc, stmt, params, 0, NULL, &error);
else
sql = gda_statement_to_sql_extended (stmt, NULL, params, 0, NULL, &error);
if (!sql) {
g_print ("Failed to render as SQL: %s\n", error && error->message ? error->message : "No detail");
g_clear_error (&error);
g_object_unref (stmt);
g_object_unref (params);
nfailed ++;
goto endtest;
}
if (!string_equal_to_template (sql, expected)) {
g_print ("Wrong rendered SQL: [%s] instead of [%s]\n", sql, expected);
g_object_unref (stmt);
g_object_unref (params);
g_free (sql);
nfailed ++;
goto endtest;
}
g_free (sql);
expected = "('@@@@@@@@@@ 15:10:23', '19:09:22')";
if (cnc)
sql = gda_connection_statement_to_sql (cnc, stmt, params, GDA_STATEMENT_SQL_TIMEZONE_TO_GMT, NULL, &error);
else
sql = gda_statement_to_sql_extended (stmt, NULL, params, GDA_STATEMENT_SQL_TIMEZONE_TO_GMT, NULL, &error);
if (!sql) {
g_print ("Failed to render as SQL: %s\n", error && error->message ? error->message : "No detail");
g_clear_error (&error);
g_object_unref (stmt);
g_object_unref (params);
nfailed ++;
goto endtest;
}
if (!string_equal_to_template (sql, expected)) {
g_print ("Wrong rendered SQL for GMT timezone: [%s] instead of [%s]\n", sql, expected);
g_object_unref (stmt);
g_object_unref (params);
g_free (sql);
nfailed ++;
goto endtest;
}
g_free (sql);
endtest:
return nfailed;
}
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;
}
/**
* 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;
}
/**
* 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;
}
/*
* 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;
}
