/**
* gda_provider_meta_execute_query:
* @prov: a #GdaProviderMeta
* @sql: a string with the SQL to execute on provider
* @params: (nullable): a #GdaSet with all paramaters to use in query
* @error: place to store errors or %NULL
*
* SQL is specific for current provider.
*
* Returns: (transfer full) (nullable): a new #GdaDataModel with as a result of the query
* Since: 6.0
* Stability: Unstable
*/
GdaDataModel *gda_provider_meta_execute_query (GdaProviderMeta *prov,
const gchar *sql,
GdaSet *params,
GError **error)
{
g_return_val_if_fail (prov, NULL);
g_return_val_if_fail (GDA_IS_PROVIDER_META (prov), NULL);
g_return_val_if_fail (sql, NULL);
GdaConnection *cnc = NULL;
GdaStatement *stmt;
g_object_get (G_OBJECT (prov), "connection", &cnc, NULL);
if (cnc == NULL) {
g_set_error (error, GDA_PROVIDER_META_ERROR, GDA_PROVIDER_META_NO_CONNECTION_ERROR,
_("No connection is set"));
return NULL;
}
if (!gda_connection_is_opened (cnc)) {
g_set_error (error, GDA_PROVIDER_META_ERROR, GDA_PROVIDER_META_NO_CONNECTION_ERROR,
_("Connection is no opened"));
return NULL;
}
stmt = gda_connection_parse_sql_string (cnc, sql, NULL, error);
if (stmt == NULL) {
return NULL;
}
if (!gda_connection_statement_prepare (cnc, stmt, error)) {
return NULL;
}
return gda_connection_statement_execute_select (cnc, stmt, params, 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;
}
gboolean
wmud_db_load_exits(GSList **exits, GError **err)
{
GdaStatement *sth = NULL;
GdaDataModel *res = NULL;
GdaDataModelIter *iter;
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading exits");
if (dbh == NULL) {
if (err) {
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
"Database backend not initialized");
}
return FALSE;
}
sth = gda_sql_parser_parse_string(
parser,
"SELECT room_id, direction, other_side FROM room_exits",
NULL,
NULL);
res = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
iter = gda_data_model_create_iter(res);
gda_data_model_iter_move_next(iter);
while (gda_data_model_iter_is_valid(iter)) {
const GValue *val;
wmudExit *room_exit;
room_exit = g_new0(wmudExit, 1);
val = gda_data_model_iter_get_value_at(iter, 0);
room_exit->source_room_id = g_value_get_int(val);
val = gda_data_model_iter_get_value_at(iter, 1);
room_exit->direction_id = g_value_get_int(val);
val = gda_data_model_iter_get_value_at(iter, 2);
room_exit->destination_room_id = g_value_get_int(val);
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
"Loaded exit %d =%d=> %d",
room_exit->source_room_id,
room_exit->direction_id,
room_exit->destination_room_id);
*exits = g_slist_prepend(*exits, room_exit);
gda_data_model_iter_move_next(iter);
}
g_object_unref(iter);
g_object_unref(sth);
return TRUE;
}
gboolean
wmud_db_load_planet_planes(GSList **planet_planes, GError **err)
{
GdaStatement *sth = NULL;
GdaDataModel *res = NULL;
GdaDataModelIter *iter;
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
"Loading planet<->plane associations");
if (dbh == NULL) {
if (err) {
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
"Database backend not initialized");
}
return FALSE;
}
sth = gda_sql_parser_parse_string(
parser,
"SELECT planet_id, plane_id FROM planet_planes",
NULL,
NULL);
res = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
iter = gda_data_model_create_iter(res);
gda_data_model_iter_move_next(iter);
while (gda_data_model_iter_is_valid(iter)) {
const GValue *val;
wmudPlanetPlaneAssoc *planet_plane;
planet_plane = g_new0(wmudPlanetPlaneAssoc, 1);
val = gda_data_model_iter_get_value_at(iter, 0);
planet_plane->planet_id = g_value_get_int(val);
val = gda_data_model_iter_get_value_at(iter, 1);
planet_plane->plane_id = g_value_get_int(val);
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
"Loaded planet-plane association %d <> %d",
planet_plane->planet_id,
planet_plane->plane_id);
*planet_planes = g_slist_prepend(*planet_planes, planet_plane);
gda_data_model_iter_move_next(iter);
}
g_object_unref(iter);
g_object_unref(sth);
return TRUE;
}
gboolean
wmud_db_load_areas(GSList **areas, GError **err)
{
GdaStatement *sth = NULL;
GdaDataModel *res = NULL;
GdaDataModelIter *iter;
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading areas");
if (dbh == NULL) {
if (err) {
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
"Database backend not initialized");
}
return FALSE;
}
sth = gda_sql_parser_parse_string(
parser,
"SELECT id, name FROM areas",
NULL,
NULL);
res = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
iter = gda_data_model_create_iter(res);
gda_data_model_iter_move_next(iter);
while (gda_data_model_iter_is_valid(iter)) {
const GValue *val;
wmudArea *area;
area = g_new0(wmudArea, 1);
val = gda_data_model_iter_get_value_at(iter, 0);
area->id = g_value_get_int(val);
val = gda_data_model_iter_get_value_at(iter, 1);
area->name = g_strdup(g_value_get_string(val));
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loaded area _%s_", area->name);
*areas = g_slist_prepend(*areas, area);
gda_data_model_iter_move_next(iter);
}
g_object_unref(iter);
g_object_unref(sth);
return TRUE;
}
static GdaDataModel *
execute_select (GdaConnection *cnc, GdaPostgresReuseable *rdata, const gchar *sql)
{
GdaSqlParser *parser;
GdaStatement *stmt;
GdaDataModel *model;
parser = _gda_postgres_reuseable_create_parser ((GdaProviderReuseable*) rdata);
stmt = gda_sql_parser_parse_string (parser, sql, NULL, NULL);
g_object_unref (parser);
g_assert (stmt);
model = gda_connection_statement_execute_select (cnc, stmt, NULL, NULL);
g_object_unref (stmt);
return model;
}
/*
* display the contents of the 'products' table
*/
void
display_customers (GdaConnection *cnc)
{
GdaDataModel *data_model;
GdaSqlParser *parser;
GdaStatement *stmt;
gchar *sql = "SELECT id, name FROM customers ORDER BY id";
GError *error = NULL;
parser = g_object_get_data (G_OBJECT (cnc), "parser");
stmt = gda_sql_parser_parse_string (parser, sql, NULL, NULL);
data_model = gda_connection_statement_execute_select (cnc, stmt, NULL, &error);
g_object_unref (stmt);
if (!data_model)
g_error ("Could not get the contents of the 'products' table: %s\n",
error && error->message ? error->message : "No detail");
gda_data_model_dump (data_model, stdout);
g_object_unref (data_model);
}
static gboolean
display_blobs (GdaConnection *cnc, GError **error)
{
GdaStatement *stmt;
gboolean retval;
GdaDataModel *model;
stmt = gda_sql_parser_parse_string (parser, "SELECT * FROM blobs", NULL, error);
if (!stmt)
return FALSE;
model = gda_connection_statement_execute_select (cnc, stmt, NULL, error);
retval = model ? TRUE : FALSE;
if (model) {
gda_data_model_dump (model, stdout);
g_object_unref (model);
}
return retval;
}
/*
* display the contents of the 'products' table
*/
void
display_products_contents (GdaConnection *cnc)
{
GdaDataModel *data_model;
GdaStatement *stmt;
gchar *sql = "SELECT * FROM products";
GError *error = NULL;
GdaSqlParser *parser;
parser = gda_connection_create_parser (cnc);
if (!parser) /* @cnc doe snot provide its own parser => use default one */
parser = gda_sql_parser_new ();
stmt = gda_sql_parser_parse_string (parser, sql, NULL, NULL);
data_model = gda_connection_statement_execute_select (cnc, stmt, NULL, &error);
g_object_unref (stmt);
if (!data_model)
g_error ("Could not get the contents of the 'products' table: %s\n",
error && error->message ? error->message : "No detail");
gda_data_model_dump (data_model, stdout);
g_object_unref (data_model);
}
GdaDataModel *
run_sql_select (GdaConnection *cnc, const gchar *sql)
{
GdaStatement *stmt;
GError *error = NULL;
GdaDataModel *res;
GdaSqlParser *parser;
parser = gda_connection_create_parser (cnc);
if (!parser)
parser = gda_sql_parser_new ();
stmt = gda_sql_parser_parse_string (parser, sql, NULL, NULL);
g_object_unref (parser);
res = gda_connection_statement_execute_select (cnc, stmt, NULL, &error);
g_object_unref (stmt);
if (!res)
g_print ("Could not execute query: %s\n",
error && error->message ? error->message : "no detail");
return res;
}
GtkWidget *
do_grid_data_layout (GtkWidget *do_widget)
{
if (!window) {
GdaStatement *stmt;
GtkWidget *vbox;
GtkWidget *label;
GdaDataModel *model;
GtkWidget *grid;
GdauiRawGrid *raw_grid;
window = gtk_dialog_new_with_buttons ("Grid with custom data layout",
GTK_WINDOW (do_widget),
0,
"Close", GTK_RESPONSE_NONE,
NULL);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))),
vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
label = gtk_label_new ("The following GdauiGrid widget displays information about customers,\n"
"using a picture of the customer.\n");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
/* Create the demo widget: select all the customers and computes the total
* amount of orders they have spent */
stmt = gda_sql_parser_parse_string (demo_parser,
"select c.id, c.name, c.country, c.city, c.photo, c.comments, sum (od.quantity * (1 - od.discount/100) * p.price) as total_orders from customers c left join orders o on (c.id=o.customer) left join order_contents od on (od.order_id=o.id) left join products p on (p.ref = od.product_ref) group by c.id order by total_orders desc",
NULL, NULL);
model = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
g_object_unref (stmt);
grid = gdaui_grid_new (model);
g_object_unref (model);
/* request custom layout:
<gdaui_grid name="customers">
<gdaui_entry name="name"/>
<gdaui_entry name="total_orders" label="Total ordered" plugin="number:NB_DECIMALS=2;CURRENCY=€"/>
<gdaui_entry name="photo" plugin="picture"/>
</gdaui_grid>
*/
g_object_get (G_OBJECT (grid), "raw-grid", &raw_grid, NULL);
gchar *filename;
filename = demo_find_file ("custom_layout.xml", NULL);
gdaui_raw_grid_set_layout_from_file (GDAUI_RAW_GRID (raw_grid), filename, "customers");
g_free (filename);
gtk_box_pack_start (GTK_BOX (vbox), grid, TRUE, TRUE, 0);
gtk_widget_set_size_request (window, 500, 500);
}
gboolean visible;
g_object_get (G_OBJECT (window), "visible", &visible, NULL);
if (!visible)
gtk_widget_show_all (window);
else {
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
GtkWidget *
do_form_pict (GtkWidget *do_widget)
{
if (!window) {
GdaStatement *stmt;
GtkWidget *vbox;
GtkWidget *label;
GdaDataModel *model;
GtkWidget *form;
GdaSet *data_set;
GdaHolder *param;
GValue *value;
window = gtk_dialog_new_with_buttons ("Form with the 'picture' plugin",
GTK_WINDOW (do_widget),
0,
GTK_STOCK_CLOSE,
GTK_RESPONSE_NONE,
NULL);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))),
vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
label = gtk_label_new ("The following GdauiForm widget displays data from the 'pictures' table.\n\n"
"The pictures are stored as BLOB inside the database and\n"
"are displayed using the 'picture' plugin (right click to \n"
"open a menu, or double click to load an image).");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
/* Create the demo widget */
stmt = gda_sql_parser_parse_string (demo_parser, "SELECT id, pict FROM pictures", NULL, NULL);
model = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
g_object_unref (stmt);
gda_data_select_compute_modification_statements (GDA_DATA_SELECT (model), NULL);
form = gdaui_form_new (model);
g_object_unref (model);
g_object_set (G_OBJECT (form), "info-flags",
GDAUI_DATA_PROXY_INFO_CURRENT_ROW |
GDAUI_DATA_PROXY_INFO_ROW_MOVE_BUTTONS |
GDAUI_DATA_PROXY_INFO_ROW_MODIFY_BUTTONS, NULL);
/* specify that we want to use the 'picture' plugin */
data_set = GDA_SET (gdaui_data_selector_get_data_set (GDAUI_DATA_SELECTOR (form)));
param = gda_set_get_holder (data_set, "pict");
value = gda_value_new_from_string ("picture", G_TYPE_STRING);
gda_holder_set_attribute_static (param, GDAUI_ATTRIBUTE_PLUGIN, value);
gda_value_free (value);
gtk_box_pack_start (GTK_BOX (vbox), form, TRUE, TRUE, 0);
}
gboolean visible;
g_object_get (G_OBJECT (window), "visible", &visible, NULL);
if (!visible)
gtk_widget_show_all (window);
else {
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
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;
}
gboolean
wmud_db_load_directions(GSList **directions, GError **err)
{
GdaStatement *sth = NULL;
GdaDataModel *res = NULL;
GdaDataModelIter *iter;
GError *local_err = NULL;
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading directions");
if (dbh == NULL) {
if (err) {
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
"Database backend not initialized");
}
return FALSE;
}
sth = gda_sql_parser_parse_string(
parser,
"SELECT id, short_name, name FROM directions",
NULL,
NULL);
if ((res = gda_connection_statement_execute_select(
dbh, sth,
NULL, &local_err)) == NULL) {
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_SELECT_ERROR,
"Unable to load directions: %s",
local_err->message);
return FALSE;
}
iter = gda_data_model_create_iter(res);
gda_data_model_iter_move_next(iter);
while (gda_data_model_iter_is_valid(iter)) {
const GValue *val;
wmudDirection *dir;
dir = g_new0(wmudDirection, 1);
val = gda_data_model_iter_get_value_at(iter, 0);
dir->id = g_value_get_int(val);
val = gda_data_model_iter_get_value_at(iter, 1);
dir->short_name = g_strdup(g_value_get_string(val));
val = gda_data_model_iter_get_value_at(iter, 2);
dir->name = g_strdup(g_value_get_string(val));
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
"Loaded direction _%s_",
dir->name);
*directions = g_slist_prepend(*directions, dir);
gda_data_model_iter_move_next(iter);
}
g_object_unref(iter);
g_object_unref(sth);
return TRUE;
}
/*
* 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;
}
GtkWidget *
do_form_rw (GtkWidget *do_widget)
{
if (!window) {
GdaStatement *stmt;
GtkWidget *vbox;
GtkWidget *label;
GdaDataModel *model;
GtkWidget *form;
window = gtk_dialog_new_with_buttons ("GdauiForm (RW)",
GTK_WINDOW (do_widget),
0,
"Close", GTK_RESPONSE_NONE,
NULL);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))),
vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
label = gtk_label_new ("The following GdauiForm widget displays data from the 'products' table.\n\n"
"As modification queries are provided, the data is read-write\n(except for the 'price' "
"field as these queries voluntarily omit that field).");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
/* Create the demo widget */
stmt = gda_sql_parser_parse_string (demo_parser,
"SELECT ref, category, name, price, wh_stored FROM products",
NULL, NULL);
model = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
g_object_unref (stmt);
GError *error = NULL;
if (!gda_data_select_compute_modification_statements (GDA_DATA_SELECT (model), &error)) {
g_print ("===> %s\n", error && error->message ? error->message : "No detail");
}
form = gdaui_form_new (model);
g_object_unref (model);
g_object_set (G_OBJECT (form), "info-flags",
GDAUI_DATA_PROXY_INFO_CURRENT_ROW |
GDAUI_DATA_PROXY_INFO_ROW_MOVE_BUTTONS |
GDAUI_DATA_PROXY_INFO_ROW_MODIFY_BUTTONS, NULL);
gtk_box_pack_start (GTK_BOX (vbox), form, TRUE, TRUE, 0);
}
gboolean visible;
g_object_get (G_OBJECT (window), "visible", &visible, NULL);
if (!visible)
gtk_widget_show_all (window);
else {
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
static void
_midgard_query_select_execute (MidgardExecutable *iface, gboolean async, GError **error)
{
g_return_if_fail (iface != NULL);
MidgardQuerySelect *self = MIDGARD_QUERY_SELECT (iface);
MidgardQueryExecutor *executor = MIDGARD_QUERY_EXECUTOR (self);
GError *err = NULL;
midgard_validable_validate (MIDGARD_VALIDABLE (self), &err);
if (err) {
g_propagate_error (error, err);
return;
}
MidgardDBObjectClass *klass = executor->priv->storage->priv->klass;
MidgardConnection *mgd = executor->priv->mgd;
GdaConnection *cnc = mgd->priv->connection;
GdaSqlStatement *sql_stm;
GdaSqlStatementSelect *sss;
sql_stm = gda_sql_statement_new (GDA_SQL_STATEMENT_SELECT);
sss = (GdaSqlStatementSelect*) sql_stm->contents;
g_assert (GDA_SQL_ANY_PART (sss)->type == GDA_SQL_ANY_STMT_SELECT);
MIDGARD_QUERY_EXECUTOR (self)->priv->stmt = sql_stm;
sss->from = gda_sql_select_from_new (GDA_SQL_ANY_PART (sss));
/* Initialize top base expresion and operation with default AND operator type */
GdaSqlExpr *base_where = gda_sql_expr_new (GDA_SQL_ANY_PART (sss));
GdaSqlOperation *base_operation = gda_sql_operation_new (GDA_SQL_ANY_PART (base_where));
base_operation->operator_type = GDA_SQL_OPERATOR_TYPE_AND;
base_where->cond = base_operation;
gda_sql_statement_select_take_where_cond (sql_stm, base_where);
/* Create targets (FROM) */
GdaSqlSelectTarget *s_target = gda_sql_select_target_new (GDA_SQL_ANY_PART (sss->from));
s_target->table_name = g_strdup (midgard_core_class_get_table (klass));
s_target->as = g_strdup_printf ("t%d", ++MIDGARD_QUERY_EXECUTOR (self)->priv->tableid);
MIDGARD_QUERY_EXECUTOR (self)->priv->table_alias = g_strdup (s_target->as);
gda_sql_select_from_take_new_target (sss->from, s_target);
/* Set target expression */
GdaSqlExpr *texpr = gda_sql_expr_new (GDA_SQL_ANY_PART (s_target));
GValue *tval = g_new0 (GValue, 1);
g_value_init (tval, G_TYPE_STRING);
g_value_set_string (tval, s_target->table_name);
texpr->value = tval;
s_target->expr = texpr;
/* Add fields for all properties registered per class (SELECT a,b,c...) */
klass->dbpriv->add_fields_to_select_statement (klass, mgd, sss, s_target->as);
GdaSqlExpr *where = sss->where_cond;
GdaSqlOperation *operation = where->cond;
/* Add joins, LEFT JOIN tbl2 ON... */
__query_select_add_joins (MIDGARD_QUERY_SELECT (self), operation, &err);
if (err) {
g_propagate_error (error, err);
goto return_false;
}
/* Add constraints' conditions (WHERE a=1, b=2...) */
if (MIDGARD_QUERY_EXECUTOR (self)->priv->constraint) {
MIDGARD_QUERY_CONSTRAINT_SIMPLE_GET_INTERFACE (MIDGARD_QUERY_EXECUTOR (self)->priv->constraint)->priv->add_conditions_to_statement (MIDGARD_QUERY_EXECUTOR (self), MIDGARD_QUERY_EXECUTOR (self)->priv->constraint, sql_stm, base_where, &err);
if (err) {
g_propagate_error (error, err);
goto return_false;
}
if (MIDGARD_QUERY_EXECUTOR (self)->priv->n_constraints == 1)
__add_second_dummy_constraint (sss, operation);
/* Add dummy constraint if operation has only one operand */
if (operation->operands && (g_slist_length (operation->operands) == 1))
__add_dummy_constraint (sss, operation);
} else {
/* no constraints, add dummy '1=1 AND 0<1' to satisfy top constraint group */
__add_dummy_constraint (sss, operation);
__add_second_dummy_constraint (sss, operation);
}
/* Add orders , ORDER BY t1.field... */
if (!__query_select_add_orders (executor, &err)) {
if (err)
g_propagate_error (error, err);
goto return_false;
}
/* Exclude deleted */
if (MGD_DBCLASS_METADATA_CLASS (klass) && !executor->priv->include_deleted)
__add_exclude_deleted_constraints (executor, sss, operation, klass);
/* Add limit, LIMIT x */
if (executor->priv->limit > 0) {
GdaSqlExpr *limit_expr = gda_sql_expr_new (GDA_SQL_ANY_PART (sss));
GValue *limit_val = g_new0 (GValue, 1);
g_value_init (limit_val, G_TYPE_STRING);
g_value_take_string (limit_val, g_strdup_printf ("%d", executor->priv->limit));
limit_expr->value = limit_val;
sss->limit_count = limit_expr;
}
/* Add offset, OFFSET x */
if (executor->priv->offset >= 0) {
GdaSqlExpr *offset_expr = gda_sql_expr_new (GDA_SQL_ANY_PART (sss));
GValue *offset_val = g_new0 (GValue, 1);
g_value_init (offset_val, G_TYPE_STRING);
g_value_take_string (offset_val, g_strdup_printf ("%d", executor->priv->offset));
offset_expr->value = offset_val;
sss->limit_offset = offset_expr;
}
/* Check structure */
if (!gda_sql_statement_check_structure (sql_stm, &err)) {
g_set_error (error, MIDGARD_EXECUTION_ERROR, MIDGARD_EXECUTION_ERROR_INTERNAL,
"Can't build SELECT statement: %s)", err && err->message ? err->message : _("Unknown reason"));
if (err)
g_clear_error (&err);
goto return_false;
}
/* Create statement */
GdaStatement *stmt = gda_statement_new ();
g_object_set (G_OBJECT (stmt), "structure", sql_stm, NULL);
gda_sql_statement_free (sql_stm);
sql_stm = NULL;
if (MGD_CNC_DEBUG (mgd)) {
gchar *debug_sql = gda_connection_statement_to_sql (cnc, stmt, NULL, GDA_STATEMENT_SQL_PRETTY, NULL, NULL);
g_debug ("QuerySelect: %s", debug_sql);
g_free (debug_sql);
}
/* execute statement */
GdaDataModel *model = NULL;
midgard_executable_execution_start (MIDGARD_EXECUTABLE(self));
model = gda_connection_statement_execute_select (cnc, stmt, NULL, &err);
g_object_unref (stmt);
if (!model && !err) {
g_set_error (error, MIDGARD_EXECUTION_ERROR, MIDGARD_EXECUTION_ERROR_INTERNAL,
"Execute error - Unknown reason, underlying error is NULL");
goto return_false;
}
if (err) {
g_set_error (error, MIDGARD_EXECUTION_ERROR, MIDGARD_EXECUTION_ERROR_INTERNAL,
"Execute error - %s", err->message);
g_error_free (err);
goto return_false;
}
executor->priv->results_count = gda_data_model_get_n_rows (model);
if (executor->priv->resultset && G_IS_OBJECT (executor->priv->resultset))
g_object_unref (G_OBJECT (executor->priv->resultset));
executor->priv->resultset = (gpointer) model;
return;
return_false:
if (sql_stm)
gda_sql_statement_free (sql_stm);
return;
}
int
main (int argc, char *argv[])
{
gda_init ();
GdaConnection *cnc;
GError *error = NULL;
GdaStatement *stmt;
GdaDataModel *model;
gchar *str;
GValue *name;
/* open connection */
cnc = open_connection ();
/* begin transaction */
if (! gda_connection_begin_transaction (cnc, NULL, GDA_TRANSACTION_ISOLATION_UNKNOWN,
&error)) {
g_print ("Could not begin transaction: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
/* execute SELECT */
stmt = gda_sql_parser_parse_string (parser, "SELECT id, name FROM customers ORDER BY id", NULL, NULL);
g_assert (stmt);
model = gda_connection_statement_execute_select (cnc, stmt, NULL, &error);
g_object_unref (stmt);
if (!model) {
g_print ("Could not execute SELECT statement: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
g_print ("** Data model is:\n");
gda_data_model_dump (model, stdout);
/*
* make sure the mete data is up to date
*/
g_print ("Computing meta data, this may take a while; in real applications, this should be cached to avoid waiting\n");
if (! gda_connection_update_meta_store (cnc, NULL, &error)) {
g_print ("Could not fetch meta data: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
/*
* Make the data model compute the modification statements which
* will actually be executed when the data model is modified
*/
if (! gda_data_select_compute_modification_statements (GDA_DATA_SELECT (model), &error)) {
g_print ("Could not compute modification statements: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
g_object_get (G_OBJECT (model), "update-stmt", &stmt, NULL);
str = gda_statement_to_sql (stmt, NULL, NULL);
g_print ("Computed UPDATE: %s\n", str);
g_free (str);
g_object_unref (stmt);
g_object_get (G_OBJECT (model), "delete-stmt", &stmt, NULL);
str = gda_statement_to_sql (stmt, NULL, NULL);
g_print ("Computed DELETE: %s\n", str);
g_free (str);
g_object_unref (stmt);
g_object_get (G_OBJECT (model), "insert-stmt", &stmt, NULL);
str = gda_statement_to_sql (stmt, NULL, NULL);
g_print ("Computed INSERT: %s\n", str);
g_free (str);
g_object_unref (stmt);
/*
* remove row 0 (1st row)
*/
g_print ("\n\n** Removing row 0\n");
if (! gda_data_model_remove_row (model, 0, &error)) {
g_print ("Could not remove row 0: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
g_print ("** Data model is now:\n");
gda_data_model_dump (model, stdout);
g_print ("** Table's contents is now:\n");
display_customers (cnc);
/*
* add a row: the row's values is a list of GValue pointers
* (or NULL pointers where the default value should be inserted
*/
GList *list;
g_print ("\n\n** Adding a row\n");
list = g_list_append (NULL, NULL);
g_value_set_string ((name = gda_value_new (G_TYPE_STRING)), "Hiro");
list = g_list_append (list, name);
if (gda_data_model_append_values (model, list, &error) == -1) {
g_print ("Could not add a row: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
gda_value_free (name);
g_list_free (list);
g_print ("** Data model is now:\n");
gda_data_model_dump (model, stdout);
g_print ("** Table's contents is now:\n");
display_customers (cnc);
/*
* alter row 2
*/
g_print ("\n\n** Modifying row 2\n");
g_value_set_string ((name = gda_value_new (G_TYPE_STRING)), "Tom");
if (! gda_data_model_set_value_at (model, 1, 2, name, &error)) {
g_print ("Could not modify row 2: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
gda_value_free (name);
g_print ("** Data model is now:\n");
gda_data_model_dump (model, stdout);
g_print ("** Table's contents is now:\n");
display_customers (cnc);
/* rollback transaction */
gda_connection_rollback_transaction (cnc, NULL, NULL);
gda_connection_close (cnc);
return 0;
}
gboolean
_gda_postgres_compute_version (GdaConnection *cnc, GdaPostgresReuseable *rdata, GError **error)
{
GdaSqlBuilder *b;
GdaStatement *stmt;
GdaDataModel *model;
b = gda_sql_builder_new (GDA_SQL_STATEMENT_SELECT);
const guint id_func = gda_sql_builder_add_function (b, "version", 0);
gda_sql_builder_add_field_value_id (b, id_func, 0);
stmt = gda_sql_builder_get_statement (b, NULL);
g_object_unref (b);
g_assert (stmt);
model = gda_connection_statement_execute_select (cnc, stmt, NULL, error);
g_object_unref (stmt);
if (!model)
return FALSE;
const GValue *cvalue;
cvalue = gda_data_model_get_value_at (model, 0, 0, NULL);
if (!cvalue) {
g_set_error (error, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_INTERNAL_ERROR, "%s",
_("Can't import data from web server"));
g_object_unref (model);
return FALSE;
}
const gchar *str;
str = g_value_get_string (cvalue);
((GdaProviderReuseable*)rdata)->server_version = g_strdup (str);
/* analyse string */
const gchar *ptr;
rdata->version_float = 0;
/* go on the first digit of version number */
ptr = str;
while (*ptr && *ptr != ' ')
ptr++;
if (*ptr) {
ptr++;
/* scan version parts */
GdaProviderReuseable *prdata = (GdaProviderReuseable*) rdata;
sscanf (ptr, "%d.%d.%d", &(prdata->major), &(prdata->minor), &(prdata->micro));
/* elaborate the version number as a float */
gfloat div = 1;
while (*ptr != ' ') {
if (*ptr != '.') {
rdata->version_float += (*ptr - '0')/div;
div *= 10;
}
ptr++;
}
}
g_object_unref (model);
/*
g_print ("VERSIONS: [%f] [%d.%d.%d]\n", rdata->version_float,
((GdaProviderReuseable*)rdata)->major,
((GdaProviderReuseable*)rdata)->minor,
((GdaProviderReuseable*)rdata)->micro);
*/
return TRUE;
}
/**
* wmud_db_load_players:
* @err: a GError to put error messages in it
*
* Loads all player records from the database
*/
gboolean
wmud_db_load_players(GError **err)
{
GdaStatement *sth = NULL;
GdaDataModel *res;
GdaDataModelIter *iter;
GError *local_err = NULL;
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading players");
if (dbh == NULL) {
if (err) {
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
"Database backend not initialized");
}
return FALSE;
}
sth = gda_sql_parser_parse_string(
parser,
"SELECT id, login, password, email FROM players",
NULL,
NULL);
/* TODO: error checking! */
if ((res = gda_connection_statement_execute_select(
dbh,
sth,
NULL,
&local_err)) == NULL) {
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"Unable to load players: %s",
local_err->message);
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_SELECT_ERROR,
"SELECT error: %s",
local_err->message);
return FALSE;
}
iter = gda_data_model_create_iter(res);
gda_data_model_iter_move_next(iter);
while (gda_data_model_iter_is_valid(iter)) {
const GValue *val;
WmudPlayer *player;
player = wmud_player_new();
val = gda_data_model_iter_get_value_at(iter, 0);
wmud_player_set_id(player, g_value_get_int(val));
val = gda_data_model_iter_get_value_at(iter, 1);
wmud_player_set_player_name(player, g_value_get_string(val));
val = gda_data_model_iter_get_value_at(iter, 2);
wmud_player_set_cpassword(player, g_value_get_string(val));
val = gda_data_model_iter_get_value_at(iter, 3);
wmud_player_set_email(player, g_value_get_string(val));
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
"Loaded player _%s_",
wmud_player_get_player_name(player));
players = g_slist_prepend(players, player);
gda_data_model_iter_move_next(iter);
}
g_object_unref(iter);
g_object_unref(sth);
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Finished loading players");
return TRUE;
}
gboolean
wmud_db_load_menu(GSList **menu_items, GError **err)
{
GdaStatement *sth = NULL;
GdaDataModel *res = NULL;
GdaDataModelIter *iter;
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading menu items");
if (dbh == NULL) {
if (err) {
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
"Database backend not initialized");
}
return FALSE;
}
sth = gda_sql_parser_parse_string(
parser,
"SELECT id, menuchar, need_active_char, placement, display_text, fnctn FROM menu ORDER BY placement",
NULL,
NULL);
res = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
iter = gda_data_model_create_iter(res);
gda_data_model_iter_move_next(iter);
while (gda_data_model_iter_is_valid(iter)) {
const GValue *val;
wmudMenu *menu_item;
menu_item = g_new0(wmudMenu, 1);
val = gda_data_model_iter_get_value_at(iter, 0);
menu_item->id = g_value_get_int(val);
val = gda_data_model_iter_get_value_at(iter, 1);
menu_item->menuchar = *(g_value_get_string(val));
val = gda_data_model_iter_get_value_at(iter, 2);
menu_item->need_active_char = g_value_get_boolean(val);
val = gda_data_model_iter_get_value_at(iter, 3);
menu_item->placement = g_value_get_int(val);
val = gda_data_model_iter_get_value_at(iter, 4);
menu_item->text = g_strdup(g_value_get_string(val));
val = gda_data_model_iter_get_value_at(iter, 5);
menu_item->func = g_strdup(g_value_get_string(val));
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
"Loaded menu item %d: %s(%c)",
menu_item->id, menu_item->text,
menu_item->menuchar);
*menu_items = g_slist_prepend(*menu_items, menu_item);
gda_data_model_iter_move_next(iter);
}
g_object_unref(iter);
g_object_unref(sth);
return TRUE;
}
GtkWidget *
do_form_model_change (GtkWidget *do_widget)
{
if (!window) {
GdaStatement *stmt;
GtkWidget *vbox;
GtkWidget *label;
GdaDataModel *models [3];
window = gtk_dialog_new_with_buttons ("Changing data in a GdauiForm",
GTK_WINDOW (do_widget),
0,
"Close", GTK_RESPONSE_NONE,
NULL);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))),
vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
label = gtk_label_new ("The data in the same GdauiForm widget can be change don the fly.");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
/* creating data models */
stmt = gda_sql_parser_parse_string (demo_parser, "SELECT * FROM products ORDER BY ref, category LIMIT 15", NULL, NULL);
models[0] = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
gda_data_select_compute_modification_statements (GDA_DATA_SELECT (models[0]), NULL);
g_object_unref (stmt);
stmt = gda_sql_parser_parse_string (demo_parser, "SELECT * FROM products WHERE price > 20.2 ORDER BY ref, category LIMIT 10", NULL, NULL);
models[1] = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
gda_data_select_compute_modification_statements (GDA_DATA_SELECT (models[1]), NULL);
g_object_unref (stmt);
stmt = gda_sql_parser_parse_string (demo_parser, "SELECT name, price, ref, category FROM products WHERE price > 20.2 ORDER BY name LIMIT 30", NULL, NULL);
models[2] = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
gda_data_select_compute_modification_statements (GDA_DATA_SELECT (models[2]), NULL);
g_object_unref (stmt);
/* allow choosing which data model to display */
label = gtk_label_new ("");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_label_set_markup (GTK_LABEL (label), "<b>Choose which data model to display:</b>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
GtkWidget *layout, *rb;
GSList *group = NULL;
gint i;
layout = gtk_grid_new ();
gtk_box_pack_start (GTK_BOX (vbox), layout, FALSE, FALSE, 0);
for (i = 0; i < 3; i++) {
gchar *str;
str = g_strdup_printf ("%d columns x %d rows", gda_data_model_get_n_columns (models[i]),
gda_data_model_get_n_rows (models[i]));
rb = gtk_radio_button_new_with_label (group, str);
g_free (str);
gtk_grid_attach (GTK_GRID (layout), rb, i, 0, 1, 1);
g_signal_connect (rb, "toggled", G_CALLBACK (model_toggled_cb), models[i]);
g_object_set_data_full (G_OBJECT (rb), "model", models[i], g_object_unref);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (rb));
}
/* Create the form widget */
label = gtk_label_new ("");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_label_set_markup (GTK_LABEL (label), "<b>GdauiForm:</b>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
form = gdaui_form_new (models[0]);
g_object_set (G_OBJECT (form), "info-flags",
GDAUI_DATA_PROXY_INFO_CURRENT_ROW |
GDAUI_DATA_PROXY_INFO_ROW_MOVE_BUTTONS |
GDAUI_DATA_PROXY_INFO_ROW_MODIFY_BUTTONS, NULL);
gtk_box_pack_start (GTK_BOX (vbox), form, TRUE, TRUE, 0);
GdaDataProxy *proxy;
proxy = gdaui_data_proxy_get_proxy (GDAUI_DATA_PROXY (form));
g_object_set (proxy, "cache-changes", TRUE, NULL);
}
gboolean visible;
g_object_get (G_OBJECT (window), "visible", &visible, NULL);
if (!visible)
gtk_widget_show_all (window);
else {
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
GtkWidget *
do_form_data_layout (GtkWidget *do_widget)
{
if (!window) {
GdaStatement *stmt;
GtkWidget *vbox;
GtkWidget *label;
GdaDataModel *model;
GtkWidget *form;
GdauiRawForm *raw_form;
window = gtk_dialog_new_with_buttons ("Form with custom data layout",
GTK_WINDOW (do_widget),
0,
"Close", GTK_RESPONSE_NONE,
NULL);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))),
vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
label = gtk_label_new ("The following GdauiForm widget displays information about customers,\n"
"using a paned container where the right part is used to display\n"
"a picture of the customer.\n");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
/* Create the demo widget: select all the customers and computes the total
* amount of orders they have spent */
stmt = gda_sql_parser_parse_string (demo_parser,
"select c.id, c.name, c.country, c.city, c.photo, c.comments, sum (od.quantity * (1 - od.discount/100) * p.price) as total_orders from customers c left join orders o on (c.id=o.customer) left join order_contents od on (od.order_id=o.id) left join products p on (p.ref = od.product_ref) group by c.id order by total_orders desc",
NULL, NULL);
model = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
g_object_unref (stmt);
form = gdaui_form_new (model);
g_object_unref (model);
/* hide the ID data entry */
g_object_get (G_OBJECT (form), "raw-form", &raw_form, NULL);
gdaui_basic_form_entry_set_visible (GDAUI_BASIC_FORM (raw_form),
gda_set_get_holder (gdaui_basic_form_get_data_set (GDAUI_BASIC_FORM (raw_form)),
"id"), FALSE);
/* request custom layout:
<gdaui_form name="customers" container="hpaned">
<gdaui_section title="Summary">
<gdaui_column>
<gdaui_entry name="id"/>
<gdaui_entry name="name" label="Customer name"/>
<gdaui_entry name="comments" label="Comments" plugin="text"/>
<gdaui_entry name="total_orders" label="Total ordered" plugin="number:NB_DECIMALS=2;CURRENCY=€"/>
</gdaui_column>
</gdaui_section>
<gdaui_section title="Photo">
<gdaui_column>
<gdaui_entry name="photo" plugin="picture"/>
</gdaui_column>
</gdaui_section>
</gdaui_form>
*/
gchar *filename;
filename = demo_find_file ("custom_layout.xml", NULL);
gdaui_basic_form_set_layout_from_file (GDAUI_BASIC_FORM (raw_form), filename, "customers");
g_free (filename);
/* we don't need the raw_form's reference anymore */
g_object_unref (G_OBJECT (raw_form));
gtk_box_pack_start (GTK_BOX (vbox), form, TRUE, TRUE, 0);
}
gboolean visible;
g_object_get (G_OBJECT (window), "visible", &visible, NULL);
if (!visible)
gtk_widget_show_all (window);
else {
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
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;
}
GPtrArray *
symbol_db_util_get_files_with_zero_symbols (SymbolDBEngine *dbe)
{
SymbolDBEnginePriv *priv;
GdaDataModel *data_model;
GPtrArray *files_to_scan;
const GdaStatement *stmt;
gint i, num_rows = 0;
g_return_val_if_fail (dbe != NULL, NULL);
priv = dbe->priv;
SDB_LOCK(priv);
if ((stmt = sdb_engine_get_statement_by_query_id (dbe,
PREP_QUERY_GET_ALL_FROM_FILE_WHERE_NOT_IN_SYMBOLS))
== NULL)
{
SDB_UNLOCK(priv);
return NULL;
}
data_model = gda_connection_statement_execute_select (priv->db_connection,
(GdaStatement*)stmt,
NULL, NULL);
if (!GDA_IS_DATA_MODEL (data_model) ||
(num_rows = gda_data_model_get_n_rows (GDA_DATA_MODEL (data_model))) <= 0)
{
if (data_model != NULL)
g_object_unref (data_model);
SDB_UNLOCK(priv);
return NULL;
}
/* initialize the array */
files_to_scan = g_ptr_array_new_with_free_func (g_free);
/* we can now scan each filename entry to check the last modification time. */
for (i = 0; i < num_rows; i++)
{
const GValue *value;
const gchar *file_name;
gchar *file_abs_path = NULL;
if ((value =
gda_data_model_get_value_at (data_model,
gda_data_model_get_column_index(data_model, "db_file_path"),
i, NULL)) == NULL)
{
continue;
}
/* build abs path. */
file_name = g_value_get_string (value);
file_abs_path = symbol_db_util_get_full_local_path (dbe, file_name);
g_ptr_array_add (files_to_scan, file_abs_path);
}
g_object_unref (data_model);
SDB_UNLOCK(priv);
return files_to_scan;
}
static GSList *
gda_tree_mgr_schemas_update_children (GdaTreeManager *manager, GdaTreeNode *node,
G_GNUC_UNUSED const GSList *children_nodes, gboolean *out_error,
GError **error)
{
GdaTreeMgrSchemas *mgr = GDA_TREE_MGR_SCHEMAS (manager);
GdaMetaStore *store;
GdaDataModel *model;
GSList *list = NULL;
GdaConnection *scnc;
if (!mgr->priv->cnc && !mgr->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 (mgr->priv->mstore)
store = mgr->priv->mstore;
else
store = gda_connection_get_meta_store (mgr->priv->cnc);
scnc = gda_meta_store_get_internal_connection (store);
if (!mgr->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 schema_name FROM _schemata "
"WHERE schema_internal = FALSE OR schema_name LIKE 'info%' "
"ORDER BY schema_name DESC", NULL, error);
g_object_unref (parser);
if (!stmt) {
if (out_error)
*out_error = TRUE;
return NULL;
}
mgr->priv->stmt = stmt;
}
model = gda_connection_statement_execute_select (scnc, mgr->priv->stmt, NULL, 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_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 schema name"));
return NULL;
}
snode = gda_tree_manager_create_node (manager, node, g_value_get_string (cvalue));
gda_tree_node_set_node_attribute (snode, "schema", cvalue, NULL);
list = g_slist_prepend (list, snode);
}
if (iter)
g_object_unref (iter);
g_object_unref (model);
return list;
}
gboolean
wmud_db_load_rooms(GSList **rooms, GError **err)
{
GdaStatement *sth = NULL;
GdaDataModel *res = NULL;
GdaDataModelIter *iter;
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading rooms");
if (dbh == NULL) {
if (err) {
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
"Database backend not initialized");
}
return FALSE;
}
sth = gda_sql_parser_parse_string(
parser,
"SELECT id, area, name, distant_description, close_description FROM rooms",
NULL,
NULL);
res = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
iter = gda_data_model_create_iter(res);
gda_data_model_iter_move_next(iter);
while (gda_data_model_iter_is_valid(iter)) {
const GValue *val;
wmudRoom *room;
room = g_new0(wmudRoom, 1);
val = gda_data_model_iter_get_value_at(iter, 0);
room->id = g_value_get_int(val);
val = gda_data_model_iter_get_value_at(iter, 1);
room->area_id = g_value_get_int(val);
val = gda_data_model_iter_get_value_at(iter, 2);
room->name = g_strdup(g_value_get_string(val));
val = gda_data_model_iter_get_value_at(iter, 3);
room->distant_description = g_strdup(g_value_get_string(val));
val = gda_data_model_iter_get_value_at(iter, 4);
room->close_description = g_strdup(g_value_get_string(val));
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
"Loaded room %d/_%s_",
room->area_id,
room->name);
*rooms = g_slist_prepend(*rooms, room);
gda_data_model_iter_move_next(iter);
}
g_object_unref(iter);
g_object_unref(sth);
return TRUE;
}
