void _midgard_metadata_set_from_data_model (MidgardDBObject *self, GdaDataModel *model, gint row, guint column_id) { g_return_if_fail (self != NULL); g_return_if_fail (model != NULL); g_return_if_fail (row > -1); MidgardDBObject *dbobject = MIDGARD_DBOBJECT (MIDGARD_METADATA (self)->priv->object); MgdSchemaTypeAttr *type_attr = MIDGARD_DBOBJECT_GET_CLASS (dbobject)->dbpriv->storage_data; MidgardMetadata *metadata = MIDGARD_METADATA (self); /* creator */ const GValue *val = gda_data_model_get_value_at (model, column_id, row, NULL); midgard_core_metadata_set_creator (metadata, (GValue *) val); /* created */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_created (metadata, val); /* revisor */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_revisor (metadata, val); /* revised */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_revised (metadata, val); /* revision */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_revision (metadata, val); /* locker */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_locker (metadata, val); /* locked */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_locked (metadata, val); /* approver */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_approver (metadata, val); /* approved */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_approved (metadata, val); /* authors */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_authors (metadata, val); /* owner */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_owner (metadata, val); /* schedule_start */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_schedule_start (metadata, val); /* schedule_end */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_schedule_end (metadata, val); /* hidden */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_hidden (metadata, val); /* navnoentry */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_navnoentry (metadata, val); /* size */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_size (metadata, val); /* published */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_published (metadata, val); /* score */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_score (metadata, val); /* imported */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_imported (metadata, val); /* exported */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_exported (metadata, val); /* deleted */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_deleted (metadata, val); /* isapproved */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_isapproved (metadata, val); /* islocked */ val = gda_data_model_get_value_at (model, ++column_id, row, NULL); midgard_core_metadata_set_islocked (metadata, val); }
static const GValue * gda_data_access_wrapper_get_value_at (GdaDataModel *model, gint col, gint row, GError **error) { GdaDataAccessWrapper *imodel; g_return_val_if_fail (GDA_IS_DATA_ACCESS_WRAPPER (model), NULL); imodel = (GdaDataAccessWrapper*) model; g_return_val_if_fail (imodel->priv, NULL); g_return_val_if_fail (imodel->priv->model, NULL); g_return_val_if_fail (row >= 0, NULL); if (col >= imodel->priv->nb_cols) { g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_COLUMN_OUT_OF_RANGE_ERROR, _("Column %d out of range (0-%d)"), col, imodel->priv->nb_cols - 1); return NULL; } if (!imodel->priv->rows) { /* imodel->priv->model is a random access model, use it */ if (imodel->priv->rows_mapping) return gda_data_model_get_value_at (imodel->priv->model, imodel->priv->rows_mapping [col], row, error); else return gda_data_model_get_value_at (imodel->priv->model, col, row, error); } else { GdaRow *gda_row; gint tmp; tmp = row; gda_row = g_hash_table_lookup (imodel->priv->rows, &tmp); if (gda_row) { GValue *val = gda_row_get_value (gda_row, col); if (gda_row_value_is_valid (gda_row, val)) return val; else return NULL; } else { g_assert (imodel->priv->iter); if (imodel->priv->iter_row < 0) { if (gda_data_model_iter_move_next (imodel->priv->iter)) { tmp = row; gda_row = g_hash_table_lookup (imodel->priv->rows, &tmp); if (row == imodel->priv->iter_row) { GValue *val = gda_row_get_value (gda_row, col); if (gda_row_value_is_valid (gda_row, val)) return val; else return NULL; } } else { g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", _("Can't set iterator's position")); return NULL; } } gda_row = NULL; if (row != imodel->priv->iter_row) { if (row > imodel->priv->iter_row) { /* need to move forward */ while ((imodel->priv->iter_row < row) && gda_data_model_iter_move_next (imodel->priv->iter)); } else { /* need to move backwards */ g_assert (imodel->priv->model_access_flags & GDA_DATA_MODEL_ACCESS_CURSOR_BACKWARD); while ((imodel->priv->iter_row > row) && gda_data_model_iter_move_prev (imodel->priv->iter)) ; } } if (! (imodel->priv->model_access_flags & GDA_DATA_MODEL_ACCESS_CURSOR_BACKWARD) || ! (imodel->priv->model_access_flags & GDA_DATA_MODEL_ACCESS_CURSOR_FORWARD)) { tmp = row; gda_row = g_hash_table_lookup (imodel->priv->rows, &tmp); if (gda_row) { GValue *val = gda_row_get_value (gda_row, col); if (gda_row_value_is_valid (gda_row, val)) return val; else return NULL; } } else { /* in this case iter can be moved forward and backward at will => we only * need to keep a pool of GdaRow for performances reasons */ tmp = row; gda_row = g_hash_table_lookup (imodel->priv->rows, &tmp); if (!gda_row) { if (! imodel->priv->rows_buffer_array) { imodel->priv->rows_buffer_array = g_array_sized_new (FALSE, FALSE, sizeof (GdaRow*), ROWS_POOL_SIZE); imodel->priv->rows_buffer_index = g_array_sized_new (FALSE, FALSE, sizeof (gint), ROWS_POOL_SIZE); } else if (imodel->priv->rows_buffer_array->len == ROWS_POOL_SIZE) { /* get rid of the oldest row (was model's index_row row)*/ gint index_row; index_row = g_array_index (imodel->priv->rows_buffer_index, gint, ROWS_POOL_SIZE - 1); g_array_remove_index (imodel->priv->rows_buffer_array, ROWS_POOL_SIZE - 1); g_array_remove_index (imodel->priv->rows_buffer_index, ROWS_POOL_SIZE - 1); g_hash_table_remove (imodel->priv->rows, &index_row); } if (gda_data_model_iter_move_to_row (imodel->priv->iter, row)) { gda_row = create_new_row (imodel); g_array_prepend_val (imodel->priv->rows_buffer_array, gda_row); g_array_prepend_val (imodel->priv->rows_buffer_index, imodel->priv->iter_row); } } GValue *val; val = gda_row ? gda_row_get_value (gda_row, col) : NULL; if (gda_row && gda_row_value_is_valid (gda_row, val)) return val; else return NULL; } } } g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", _("Can't access data")); return NULL; }
SimEvent * sim_event_light_new_from_dm (GdaDataModel *dm, gint row) { SimEvent *event; const GValue *value; const GdaBinary *binary; const GdaTimestamp *timestamp; struct tm tm; g_return_val_if_fail (GDA_IS_DATA_MODEL (dm), NULL); event = sim_event_new (); event->id = sim_uuid_new (); value = gda_data_model_get_value_at (dm, 0, row, NULL); if (!gda_value_is_null (value)) { binary = (GdaBinary *) gda_value_get_blob (value); event->src_ia = sim_inet_new_from_db_binary (binary->data, binary->binary_length); } value = gda_data_model_get_value_at (dm, 1, row, NULL); if (!gda_value_is_null (value)) { binary = (GdaBinary *) gda_value_get_blob (value); event->dst_ia = sim_inet_new_from_db_binary (binary->data, binary->binary_length); } value = gda_data_model_get_value_at (dm, 2, row, NULL); if (!gda_value_is_null (value)) event->src_id = sim_uuid_new_from_blob (gda_value_get_blob (value)); value = gda_data_model_get_value_at (dm, 3, row, NULL); if (!gda_value_is_null (value)) event->dst_id = sim_uuid_new_from_blob (gda_value_get_blob (value)); value = gda_data_model_get_value_at (dm, 4, row, NULL); event->src_port = gda_value_is_null (value) ? 0 : g_value_get_int (value); value = gda_data_model_get_value_at (dm, 5, row, NULL); event->dst_port = gda_value_is_null (value) ? 0 : g_value_get_int (value); value = gda_data_model_get_value_at (dm, 6, row, NULL); if (!gda_value_is_null (value)) { timestamp = gda_value_get_timestamp (value); tm.tm_year = timestamp->year - 1900; tm.tm_mon = timestamp->month - 1; tm.tm_mday = timestamp->day; tm.tm_hour = timestamp->hour - 1; tm.tm_min = timestamp->minute; tm.tm_mday = timestamp->day; tm.tm_sec = timestamp->second; tm.tm_wday = 0; tm.tm_yday = 0; tm.tm_isdst = 0; event->time = mktime (&tm); } value = gda_data_model_get_value_at (dm, 7, row, NULL); event->tzone = gda_value_is_null (value) ? 0.0 : g_value_get_float (value); return event; }
/* * 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 gboolean gda_data_model_dir_set_values (GdaDataModel *model, gint row, GList *values, GError **error) { GdaDataModelDir *imodel; GList *list; gint col; FileRow *frow; gboolean has_changed = FALSE; g_return_val_if_fail (GDA_IS_DATA_MODEL_DIR (model), FALSE); g_return_val_if_fail (row >= 0, FALSE); imodel = (GdaDataModelDir *) model; g_return_val_if_fail (imodel->priv, FALSE); if (!values) return TRUE; if ((guint)row >= imodel->priv->rows->len) { gchar *str; if (imodel->priv->rows->len > 0) str = g_strdup_printf (_("Row %d out of range (0-%d)"), row, imodel->priv->rows->len - 1); else str = g_strdup_printf (_("Row %d not found (empty data model)"), row); add_error (imodel, str); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ROW_OUT_OF_RANGE_ERROR, "%s", str); g_free (str); return FALSE; } frow = g_ptr_array_index (imodel->priv->rows, row); for (col = 0, list = values; list; list = list->next, col++) { GValue *value = (GValue *) list->data; const GValue *cvalue = gda_data_model_get_value_at (model, col, row, error); if (!cvalue) return FALSE; if (!value || !gda_value_compare (value, cvalue)) continue; switch (col) { case COL_SIZE: case COL_MIME: case COL_MD5SUM: default: add_error (imodel, _("Column cannot be modified")); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", _("Column cannot be modified")); return FALSE; case COL_DIRNAME: { /* check that the new dir still starts with the basedir */ const gchar *new_path; gchar *old_path; gint len, base_len; new_path = value ? g_value_get_string (value) : ""; len = strlen (new_path); base_len = strlen (imodel->priv->basedir); if ((len < base_len) || (strncmp (new_path, imodel->priv->basedir, base_len))) { add_error (imodel, _("New path must be a subpath of the base directory")); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", _("New path must be a subpath of the base directory")); return FALSE; } old_path = compute_dirname (imodel, frow); if (dir_equal (new_path, old_path)) { g_free (old_path); g_print ("Paths are equal...\n"); break; } if (!g_mkdir_with_parents (new_path, 0755)) { gchar *new_filename; GMappedFile *old_file; gboolean allok = FALSE; gchar *filename; new_filename = g_build_filename (new_path, frow->raw_filename_value ? frow->raw_filename_value : g_value_get_string (frow->filename_value), NULL); filename = compute_filename (imodel, frow); old_file = g_mapped_file_new (filename, FALSE, NULL); if (old_file) { if (g_file_set_contents (new_filename, g_mapped_file_get_contents (old_file), g_mapped_file_get_length (old_file), NULL)) { g_unlink (filename); allok = TRUE; if (frow->data_value) { GdaBlob *blob; blob = (GdaBlob *) gda_value_get_blob (frow->data_value); if (blob && blob->op) _gda_dir_blob_set_filename (GDA_DIR_BLOB_OP (blob->op), new_filename); } } g_mapped_file_unref (old_file); } if (!allok) { gchar *str; str = g_strdup_printf (_("Could not rename file '%s' to '%s'"), filename, new_filename); add_error (imodel, str); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", str); g_free (str); g_free (new_filename); g_free (filename); g_free (old_path); return FALSE; } else { /* renaming succeeded => update FileRow */ #ifndef G_OS_WIN32 g_rmdir (old_path); #endif g_free (frow->reldir); frow->reldir = g_strdup (new_path + base_len); } g_free (filename); g_free (new_filename); has_changed = TRUE; } else { gchar *str; str = g_strdup_printf (_("Could not create directory '%s'"), new_path); add_error (imodel, str); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", str); g_free (str); g_free (old_path); return FALSE; } g_free (old_path); break; } case COL_FILENAME: { gchar *new_filename; gchar *filename; new_filename = g_build_filename (imodel->priv->basedir, frow->reldir, g_value_get_string (value), NULL); filename = compute_filename (imodel, frow); if (g_rename (filename, new_filename)) { gchar *str; str = g_strdup_printf (_("Could not rename file '%s' to '%s'"), filename, new_filename); add_error (imodel, str); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", str); g_free (str); g_free (new_filename); g_free (filename); return FALSE; } else { /* renaming succeeded => update FileRow */ gda_value_free (frow->filename_value); frow->filename_value = gda_value_copy (value); if (frow->raw_filename_value) { g_free (frow->raw_filename_value); frow->raw_filename_value = g_strdup (g_value_get_string (value)); } if (frow->data_value) { GdaBlob *blob; blob = (GdaBlob *) gda_value_get_blob (frow->data_value); if (blob && blob->op) _gda_dir_blob_set_filename (GDA_DIR_BLOB_OP (blob->op), new_filename); } } g_free (new_filename); g_free (filename); has_changed = TRUE; break; } case COL_DATA: { GdaBlob *blob = NULL; if (gda_value_isa (value, GDA_TYPE_BLOB)) { blob = (GdaBlob *) gda_value_get_blob (value); } else if (gda_value_isa (value, GDA_TYPE_BINARY)) { blob = (GdaBlob *) gda_value_get_binary (value); } else if (gda_value_is_null (value)) { /* create a new empty blob */ blob = g_new0 (GdaBlob, 1); } if (blob) { GdaBlobOp *op; gchar *filename; filename = compute_filename (imodel, frow); op = _gda_dir_blob_op_new (filename); if (gda_blob_op_write_all (op, blob) < 0) { gchar *str; str = g_strdup_printf (_("Could not overwrite contents of file '%s'"), filename); add_error (imodel, str); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", str); g_free (str); g_object_unref (op); g_free (filename); return FALSE; } g_object_unref (op); if (gda_value_is_null (value)) g_free (blob); has_changed = FALSE; has_changed = update_file_size (frow, filename); has_changed = update_file_md5sum (frow, filename) || has_changed; has_changed = update_file_mime (frow, filename) || has_changed; g_free (filename); } else { add_error (imodel, _("Wrong type of data")); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", _("Wrong type of data")); return FALSE; } break; } } } if (has_changed) /* signal changes to data model */ gda_data_model_row_updated ((GdaDataModel *) model, row); return TRUE; }
int main (int argc, char *argv []) { GdaDataModel *model; gint i, nrows; GError *error = NULL; gda_init (); if (! g_file_test (DATABASE, G_FILE_TEST_EXISTS)) { g_print ("File '%s' does not exist\n", DATABASE); exit (1); } model = gda_data_model_bdb_new (DATABASE, NULL); gda_data_model_dump (model, stdout); nrows = gda_data_model_get_n_rows (model); for (i = 0; i < nrows; i++) { Key *key; Value *value; const GValue *c_value; const GdaBinary *bin; g_print ("=============== ROW %d\n", i); c_value= gda_data_model_get_value_at (model, 0, i, &error); if (!c_value) { g_print ("Could not get value from data model: %s\n", error && error->message ? error->message : "No detail"); exit (1); } bin = gda_value_get_binary (c_value); key = (Key *)bin->data; g_print ("color/type = %s/%d\n", key->color, key->type); c_value= gda_data_model_get_value_at (model, 1, i, &error); if (!c_value) { g_print ("Could not get value from data model: %s\n", error && error->message ? error->message : "No detail"); exit (1); } bin = gda_value_get_binary (c_value); value = (Value *)bin->data; g_print ("size/name = %f/%s\n", value->size, value->name); } i = gda_data_model_append_row (model, &error); if (i < 0) { g_print ("Could not append row: %s\n", error && error->message ? error->message : "no detail"); exit (1); } else { { /* EXTRA tests */ gda_data_model_dump (model, stdout); if (!gda_data_model_remove_row (model, i, &error)) { g_print ("Could not remove row: %s\n", error && error->message ? error->message : "no detail"); exit (1); } gda_data_model_dump (model, stdout); gchar *str = "AAA"; GValue *value = gda_value_new_binary ((guchar*) str, 4); if (!gda_data_model_set_value_at (model, 1, 2, value, &error)) { g_print ("Could not set value: %s\n", error && error->message ? error->message : "no detail"); exit (1); } gda_data_model_dump (model, stdout); exit (0); } GValue *value; GdaBinary bin; Key m_key; Value m_value; strncpy (m_key.color, "black", COLORSIZE); m_key.type = 100; bin.data = (gpointer) &m_key; bin.binary_length = sizeof (Key); value = gda_value_new (GDA_TYPE_BINARY); gda_value_set_binary (value, &bin); if (!gda_data_model_set_value_at (model, 0, i, value, &error)) { g_print ("Could not set key: %s\n", error && error->message ? error->message : "no detail"); exit (1); } gda_value_free (value); m_value.size = 100.1; strncpy (m_value.name, "blackhole", NAMESIZE); bin.data = (gpointer) &m_value; bin.binary_length = sizeof (Value); value = gda_value_new (GDA_TYPE_BINARY); gda_value_set_binary (value, &bin); if (!gda_data_model_set_value_at (model, 1, i, value, &error)) { g_print ("Could not set key: %s\n", error && error->message ? error->message : "no detail"); exit (1); } gda_value_free (value); } g_object_unref (model); return 0; }
static void extract_named_parameters (GdaServerOperation *op, const gchar *root_path, GtkTextBuffer *tbuffer) { GdaServerOperationNode *node; GtkTextIter iter; gchar *str; node = gda_server_operation_get_node_info (op, root_path); g_return_if_fail (node); gtk_text_buffer_get_end_iter (tbuffer, &iter); gtk_text_buffer_insert (tbuffer, &iter, " * ", -1); if (node->status == GDA_SERVER_OPERATION_STATUS_REQUIRED) gtk_text_buffer_insert_with_tags_by_name (tbuffer, &iter, root_path, -1, "req_pathname", NULL); else gtk_text_buffer_insert_with_tags_by_name (tbuffer, &iter, root_path, -1, "opt_pathname", NULL); gtk_text_buffer_insert (tbuffer, &iter, " (", -1); switch (node->type) { case GDA_SERVER_OPERATION_NODE_PARAMLIST: { GSList *params; str = g_strdup_printf ("GdaSet @%p)\n", node->plist); gtk_text_buffer_insert (tbuffer, &iter, str, -1); g_free (str); for (params = node->plist->holders; params; params = params->next) { gchar *npath; npath = g_strdup_printf ("%s/%s", root_path, gda_holder_get_id (GDA_HOLDER (params->data))); extract_named_parameters (op, npath, tbuffer); g_free (npath); } break; } case GDA_SERVER_OPERATION_NODE_DATA_MODEL: { gint i, ncols; str = g_strdup_printf ("GdaDataModel @%p)\n", node->model); gtk_text_buffer_insert (tbuffer, &iter, str, -1); g_free (str); ncols = gda_data_model_get_n_columns (node->model); for (i = 0; i < ncols; i++) { GdaColumn *col = gda_data_model_describe_column (node->model, i); gchar *npath, *str; g_object_get (G_OBJECT (col), "id", &str, NULL); npath = g_strdup_printf ("%s/@%s", root_path, str); g_free (str); extract_named_parameters (op, npath, tbuffer); g_free (npath); } break; } case GDA_SERVER_OPERATION_NODE_PARAM: { gchar *str; const GValue *value; gtk_text_buffer_insert (tbuffer, &iter, "GdaHolder) = ", -1); value = gda_holder_get_value (node->param); str = gda_value_stringify (value); gtk_text_buffer_insert (tbuffer, &iter, str, -1); gtk_text_buffer_insert (tbuffer, &iter, "\n", -1); g_free (str); break; } case GDA_SERVER_OPERATION_NODE_SEQUENCE: { gtk_text_buffer_insert (tbuffer, &iter, "Sequence)\n", -1); guint i, size = gda_server_operation_get_sequence_size (op, root_path); for (i = 0; i < size; i++) { gchar **names; names = gda_server_operation_get_sequence_item_names (op, root_path); guint n; for (n = 0; names [n]; n++) { gchar *npath; npath = g_strdup_printf ("%s/%u%s", root_path, i, names [n]); extract_named_parameters (op, npath, tbuffer); g_free (npath); } g_strfreev (names); } break; } case GDA_SERVER_OPERATION_NODE_SEQUENCE_ITEM: gtk_text_buffer_insert (tbuffer, &iter, "Sequence item)\n", -1); break; case GDA_SERVER_OPERATION_NODE_DATA_MODEL_COLUMN: { gint j, nrows; gtk_text_buffer_insert (tbuffer, &iter, "Model column)\n", -1); nrows = gda_data_model_get_n_rows (node->model); for (j = 0; j < nrows; j++) { gchar *npath, *str; const GValue *value; npath = g_strdup_printf ("%s/%d", root_path, j); value = gda_data_model_get_value_at (node->model, gda_column_get_position (node->column), j, NULL); if (value) str = gda_value_stringify (value); else str = g_strdup ("Error: could not read data model's value"); gtk_text_buffer_insert (tbuffer, &iter, " * ", -1); gtk_text_buffer_insert_with_tags_by_name (tbuffer, &iter, npath, -1, "opt_pathname", NULL); g_free (npath); gtk_text_buffer_insert (tbuffer, &iter, " (GValue) = ", -1); gtk_text_buffer_insert (tbuffer, &iter, str, -1); gtk_text_buffer_insert (tbuffer, &iter, "\n", -1); g_free (str); } break; } default: gtk_text_buffer_insert (tbuffer, &iter, "???", -1); break; } }
int main (int argc, char** argv) { xmlDocPtr doc; xmlNodePtr root, node; GdaSqlParser *parser; gint failures = 0; gint ntests = 0; gchar *fname; GHashTable *parsers_hash; GdaDataModel *providers_model; gint i; gda_init (); /* load file */ fname = g_build_filename (ROOT_DIR, "tests", "parser", "testdata.xml", NULL); if (! g_file_test (fname, G_FILE_TEST_EXISTS)) { g_print ("File '%s' does not exist\n", fname); exit (1); } /* create parsers */ parsers_hash = g_hash_table_new (g_str_hash, g_str_equal); providers_model = gda_config_list_providers (); for (i = 0; i < gda_data_model_get_n_rows (providers_model); i++) { const GValue *pname; GError *lerror = NULL; pname = gda_data_model_get_value_at (providers_model, 0, i, &lerror); if (!pname) { g_print ("Can't get data model's value: %s", lerror && lerror->message ? lerror->message : "No detail"); exit (1); } parser = create_parser_for_provider (g_value_get_string (pname)); g_hash_table_insert (parsers_hash, g_strdup (g_value_get_string (pname)), parser); g_print ("Created parser for provider %s\n", g_value_get_string (pname)); } g_object_unref (providers_model); g_hash_table_insert (parsers_hash, "", gda_sql_parser_new ()); /* use test data */ doc = xmlParseFile (fname); g_free (fname); g_assert (doc); root = xmlDocGetRootElement (doc); g_assert (!strcmp ((gchar*) root->name, "testdata")); for (node = root->children; node; node = node->next) { if (strcmp ((gchar*) node->name, "test")) continue; xmlNodePtr snode; xmlChar *sql = NULL; xmlChar *id; xmlChar *prov_name; prov_name = xmlGetProp (node, BAD_CAST "provider"); if (prov_name) { parser = g_hash_table_lookup (parsers_hash, (gchar *) prov_name); xmlFree (prov_name); } else parser = g_hash_table_lookup (parsers_hash, ""); if (!parser) continue; id = xmlGetProp (node, BAD_CAST "id"); for (snode = node->children; snode; snode = snode->next) { if (!strcmp ((gchar*) snode->name, "sql")) sql = xmlNodeGetContent (snode); else if (!strcmp ((gchar*) snode->name, "expected")) { xmlChar *expected; xmlChar *mode; expected = xmlNodeGetContent (snode); mode = xmlGetProp (snode, BAD_CAST "mode"); if (sql) { g_object_set (G_OBJECT (parser), "mode", mode && !strcmp ((gchar *) mode, "delim") ? GDA_SQL_PARSER_MODE_DELIMIT : GDA_SQL_PARSER_MODE_PARSE, NULL); failures += do_test (parser, id, sql, expected, NULL, NULL); ntests++; } else g_print ("===== Test '%s' doe not have any <sql> tag!\n", id); if (expected) xmlFree (expected); if (mode) xmlFree (mode); } else if (!strcmp ((gchar*) snode->name, "error")) { xmlChar *error_line, *error_col; xmlChar *mode; mode = xmlGetProp (snode, BAD_CAST "mode"); error_line = xmlGetProp (snode, BAD_CAST "line"); error_col = xmlGetProp (snode, BAD_CAST "col"); if (sql) { g_object_set (G_OBJECT (parser), "mode", mode && !strcmp ((gchar *) mode, "delim") ? GDA_SQL_PARSER_MODE_DELIMIT : GDA_SQL_PARSER_MODE_PARSE, NULL); failures += do_test (parser, id, sql, NULL, error_line, error_col); ntests++; } else g_print ("===== Test '%s' doe not have any <sql> tag!\n", id); if (mode) xmlFree (mode); if (error_line) xmlFree (error_line); if (error_col) xmlFree (error_col); } } /* mem free */ if (sql) xmlFree (sql); if (id) xmlFree (id); } xmlFreeDoc (doc); g_print ("TESTS COUNT: %d\n", ntests); g_print ("FAILURES: %d\n", failures); return failures != 0 ? 1 : 0; }
/* * render SQL */ static gboolean test2 (GError **error) { GdaSqlParser *parser = NULL; GHashTable *parsers_hash; GdaDataModel *providers_model; gint i; /* create parsers */ parsers_hash = g_hash_table_new (g_str_hash, g_str_equal); providers_model = gda_config_list_providers (); for (i = 0; i < gda_data_model_get_n_rows (providers_model); i++) { const GValue *pname; pname = gda_data_model_get_value_at (providers_model, 0, i, error); if (!pname) return FALSE; parser = create_parser_for_provider (g_value_get_string (pname)); g_hash_table_insert (parsers_hash, g_strdup (g_value_get_string (pname)), parser); g_print ("Created parser for provider %s\n", g_value_get_string (pname)); } g_object_unref (providers_model); g_hash_table_insert (parsers_hash, "", gda_sql_parser_new ()); xmlDocPtr doc; xmlNodePtr root, node; gchar *fname; fname = g_build_filename (ROOT_DIR, "tests", "parser", "testdata.xml", NULL); if (! g_file_test (fname, G_FILE_TEST_EXISTS)) { g_set_error (error, TEST_ERROR, TEST_ERROR_GENERIC, "File '%s' does not exist\n", fname); return FALSE; } doc = xmlParseFile (fname); g_free (fname); g_assert (doc); root = xmlDocGetRootElement (doc); g_assert (!strcmp ((gchar*) root->name, "testdata")); for (node = root->children; node; node = node->next) { if (strcmp ((gchar*) node->name, "test")) continue; xmlNodePtr snode; xmlChar *sql = NULL; xmlChar *id; xmlChar *prov_name; prov_name = xmlGetProp (node, BAD_CAST "provider"); if (prov_name) { parser = g_hash_table_lookup (parsers_hash, (gchar *) prov_name); xmlFree (prov_name); } else parser = g_hash_table_lookup (parsers_hash, ""); if (!parser) continue; for (snode = node->children; snode && strcmp ((gchar*) snode->name, "sql"); snode = snode->next); if (!snode) continue; sql = xmlNodeGetContent (snode); if (!sql) continue; GdaStatement *stmt; GError *lerror = NULL; stmt = gda_sql_parser_parse_string (parser, sql, NULL, &lerror); xmlFree (sql); id = xmlGetProp (node, BAD_CAST "id"); g_print ("===== TEST %s\n", id); if (!stmt) { /* skip that SQL if it can't be parsed */ g_error_free (lerror); continue; } else { GdaStatement *stmt2; gchar *rsql; gchar *ser1, *ser2; rsql = gda_statement_to_sql_extended (stmt, NULL, NULL, 0, NULL, &lerror); if (!rsql) { g_print ("REM: test '%s' can't be rendered: %s\n", id, lerror && lerror->message ? lerror->message : "No detail"); xmlFree (id); continue; } /*g_print ("--> rendered SQL: %s\n", rsql);*/ stmt2 = gda_sql_parser_parse_string (parser, rsql, NULL, error); if (!stmt2) return FALSE; GdaSqlStatement *sqlst; g_object_get (G_OBJECT (stmt), "structure", &sqlst, NULL); g_free (sqlst->sql); sqlst->sql = NULL; ser1 = gda_sql_statement_serialize (sqlst); gda_sql_statement_free (sqlst); g_object_get (G_OBJECT (stmt2), "structure", &sqlst, NULL); g_free (sqlst->sql); sqlst->sql = NULL; ser2 = gda_sql_statement_serialize (sqlst); gda_sql_statement_free (sqlst); if (strcmp (ser1, ser2)) { g_set_error (error, TEST_ERROR, TEST_ERROR_GENERIC, "Statement failed, ID: %s\nSQL: %s\nSER1: %s\nSER2 :%s", id, rsql, ser1, ser2); g_free (ser1); g_free (ser2); return FALSE; } g_free (rsql); g_free (ser1); g_free (ser2); g_object_unref (stmt); g_object_unref (stmt2); } xmlFree (id); if (lerror) g_error_free (lerror); } g_object_unref (parser); 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; }