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;
}
