static GSList *
node_func (GdaTreeManager *manager, GdaTreeNode *node, const GSList *children_nodes,
G_GNUC_UNUSED gboolean *out_error, G_GNUC_UNUSED GError **error)
{
if (children_nodes) {
/* we don't create or modify already created GdaTreeNode object => simply ref them */
g_slist_foreach ((GSList*) children_nodes, (GFunc) g_object_ref, NULL);
return g_slist_copy ((GSList*) children_nodes);
}
else {
GSList *list;
GdaTreeNode *snode;
GValue *scale;
snode = gda_tree_manager_create_node (manager, node, "Scaling...");
g_value_set_double ((scale = gda_value_new (G_TYPE_DOUBLE)), 1.);
gda_tree_node_set_node_attribute (snode, "scale", scale, NULL);
gda_value_free (scale);
g_timeout_add (50, (GSourceFunc) timout_cb, g_object_ref (snode));
g_value_set_boolean ((scale = gda_value_new (G_TYPE_BOOLEAN)), TRUE);
gda_tree_node_set_node_attribute (snode, "scale-set", scale, NULL);
gda_value_free (scale);
list = g_slist_append (NULL, snode);
return list;
}
}
static void
meta_changed_cb (G_GNUC_UNUSED TConnection *tcnc, GdaMetaStruct *mstruct, TableRelations *trels)
{
GdaMetaDbObject *dbo;
GValue *tname, *tschema;
BrowserCanvasTable *ctable;
g_object_set (G_OBJECT (trels->priv->canvas), "meta-struct", mstruct, NULL);
g_value_set_string ((tschema = gda_value_new (G_TYPE_STRING)),
table_info_get_table_schema (trels->priv->tinfo));
g_value_set_string ((tname = gda_value_new (G_TYPE_STRING)),
table_info_get_table_name (trels->priv->tinfo));
ctable = browser_canvas_db_relations_add_table (BROWSER_CANVAS_DB_RELATIONS (trels->priv->canvas), NULL,
tschema, tname);
browser_canvas_db_relations_select_table (BROWSER_CANVAS_DB_RELATIONS (trels->priv->canvas),
ctable);
dbo = gda_meta_struct_get_db_object (mstruct, NULL, tschema, tname);
if (dbo && (dbo->obj_type == GDA_META_DB_TABLE)) {
GdaMetaTable *table;
table = GDA_META_TABLE (dbo);
GSList *list;
for (list = table->reverse_fk_list; list; list = list->next) {
GdaMetaTableForeignKey *fkey = (GdaMetaTableForeignKey*) list->data;
if (! trels->priv->all_schemas &&
! strcmp (fkey->meta_table->obj_short_name, fkey->meta_table->obj_full_name))
continue;
g_value_set_string (tname, fkey->meta_table->obj_name);
g_value_set_string (tschema, fkey->meta_table->obj_schema);
browser_canvas_db_relations_add_table (BROWSER_CANVAS_DB_RELATIONS (trels->priv->canvas),
NULL,
tschema, tname);
}
for (list = table->fk_list; list; list = list->next) {
GdaMetaTableForeignKey *fkey = (GdaMetaTableForeignKey*) list->data;
if (! trels->priv->all_schemas &&
(fkey->depend_on->obj_type != GDA_META_DB_UNKNOWN) &&
! strcmp (fkey->depend_on->obj_short_name, fkey->depend_on->obj_full_name))
continue;
g_value_set_string (tname, fkey->depend_on->obj_name);
g_value_set_string (tschema, fkey->depend_on->obj_schema);
browser_canvas_db_relations_add_table (BROWSER_CANVAS_DB_RELATIONS (trels->priv->canvas),
NULL,
tschema, tname);
}
}
gda_value_free (tschema);
gda_value_free (tname);
browser_canvas_perform_auto_layout (BROWSER_CANVAS (trels->priv->canvas), TRUE,
BROWSER_CANVAS_LAYOUT_DEFAULT);
}
int
main (int argc, char *argv [])
{
GdaDataModel *model;
gint i, nrows;
GError *error = NULL;
gda_init ();
model = g_object_new (TYPE_CUSTOM_DATA_MODEL, "filename", DATABASE, NULL);
gda_data_model_dump (model, stdout);
nrows = gda_data_model_get_n_rows (model);
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 {
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;
}
void
_midgard_sql_query_constraint_add_conditions_to_statement (MidgardQueryExecutor *executor, MidgardQueryConstraintSimple *constraint_simple, GdaSqlStatement *stmt, GdaSqlExpr *where_expr_node, GError **error)
{
MidgardSqlQueryConstraint *self = MIDGARD_SQL_QUERY_CONSTRAINT (constraint_simple);
MidgardConnection *mgd = executor->priv->mgd;
GdaConnection *cnc = mgd->priv->connection;
GdaSqlStatementSelect *select = stmt->contents;
GdaSqlExpr *top_where, *where, *expr;
GdaSqlOperation *top_operation, *cond;
GValue *value;
/* Create table_alias.field name */
MidgardSqlQueryColumn *column = midgard_sql_query_constraint_get_column (self);
gchar *table_alias_field = get_real_table_field (executor, column);
g_object_unref (column);
if (!table_alias_field) {
/* TODO */
/* Handle error */
}
if (where_expr_node) {
top_where = where_expr_node;
top_operation = top_where->cond;
} else {
top_where = select->where_cond;
top_operation = top_where->cond;
}
where = gda_sql_expr_new (GDA_SQL_ANY_PART (top_operation));
top_operation->operands = g_slist_append (top_operation->operands, where);
cond = gda_sql_operation_new (GDA_SQL_ANY_PART (where));
where->cond = cond;
cond->operator_type = self->priv->op_type;
expr = gda_sql_expr_new (GDA_SQL_ANY_PART (cond));
g_value_take_string ((value = gda_value_new (G_TYPE_STRING)), table_alias_field);
expr->value = value;
cond->operands = g_slist_append (cond->operands, expr);
expr = gda_sql_expr_new (GDA_SQL_ANY_PART (cond));
/* Create value */
GValue val = {0, };
midgard_query_holder_get_value (MIDGARD_QUERY_HOLDER (self->priv->holder), &val);
//FIXME, create parameter name::type */
expr->value = gda_value_new (G_TYPE_STRING);
GString *str = g_string_new ("");
__get_expression_value (cnc, &val, str);
g_value_take_string (expr->value, g_string_free (str, FALSE));
g_value_unset (&val);
cond->operands = g_slist_append (cond->operands, expr);
/* increase executor's constraints number */
executor->priv->n_constraints++;
}
static void
meta_changed_cb (G_GNUC_UNUSED BrowserConnection *bcnc, GdaMetaStruct *mstruct, TablePreferences *tpref)
{
gtk_list_store_clear (tpref->priv->columns_store);
tpref->priv->current_table = NULL;
tpref->priv->current_column = NULL;
if (!mstruct)
return;
GdaMetaDbObject *dbo;
GValue *schema_v = NULL, *name_v;
const gchar *str;
str = table_info_get_table_schema (tpref->priv->tinfo);
if (str)
g_value_set_string ((schema_v = gda_value_new (G_TYPE_STRING)), str);
str = table_info_get_table_name (tpref->priv->tinfo);
g_value_set_string ((name_v = gda_value_new (G_TYPE_STRING)), str);
dbo = gda_meta_struct_get_db_object (mstruct, NULL, schema_v, name_v);
if (schema_v)
gda_value_free (schema_v);
gda_value_free (name_v);
if (dbo) {
GdaMetaTable *mtable = GDA_META_TABLE (dbo);
GSList *list;
tpref->priv->current_table = mtable;
for (list = mtable->columns; list; list = list->next) {
GdaMetaTableColumn *column = GDA_META_TABLE_COLUMN (list->data);
GtkTreeIter iter;
gchar *eprops;
GError *error = NULL;
eprops = browser_connection_get_table_column_attribute (tpref->priv->bcnc,
tpref->priv->current_table,
column,
BROWSER_CONNECTION_COLUMN_PLUGIN,
&error);
if (error) {
TO_IMPLEMENT; /* FIXME: add a notice somewhere in the UI */
g_warning ("Error: %s\n", error->message);
g_clear_error (&error);
}
gtk_list_store_append (tpref->priv->columns_store, &iter);
gtk_list_store_set (tpref->priv->columns_store, &iter,
COLUMN_POINTER, column,
COLUMN_GTYPE, column->gtype,
COLUMN_PLUGIN, eprops,
-1);
g_free (eprops);
}
}
}
static void
__add_join (Psh *holder)
{
MidgardCRCoreQueryExecutor *executor = MIDGARD_CR_CORE_QUERY_EXECUTOR (holder->executor);
GdaSqlStatement *sql_stm = executor->priv->stmt;
GdaSqlStatementSelect *select = (GdaSqlStatementSelect *) sql_stm->contents;
GdaSqlSelectFrom *from = select->from;
GdaSqlSelectJoin *join = gda_sql_select_join_new (GDA_SQL_ANY_PART (from));
join->type = GDA_SQL_SELECT_JOIN_LEFT;
GdaSqlExpr *expr = gda_sql_expr_new (GDA_SQL_ANY_PART (join));
expr->value = gda_value_new (G_TYPE_STRING);
g_value_take_string (expr->value, g_strdup_printf ("%s.%s = %s.%s",
holder->table_alias, holder->colname, holder->target_table_alias, holder->target_colname));
join->expr = expr;
join->position = ++executor->priv->joinid;
gda_sql_select_from_take_new_join (from , join);
GdaSqlSelectTarget *s_target = gda_sql_select_target_new (GDA_SQL_ANY_PART (from));
s_target->table_name = g_strdup (holder->target_table);
s_target->as = g_strdup (holder->target_table_alias);
gda_sql_select_from_take_new_target (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;
}
/* Returns: TRUE if FileRow value has been changed */
static gboolean
update_file_size (FileRow *row, const gchar *complete_filename)
{
struct stat filestat;
gboolean changed = TRUE;
if (! g_stat (complete_filename, &filestat)) {
if (row->size_value && (G_VALUE_TYPE (row->size_value) == G_TYPE_UINT)
&& (g_value_get_uint (row->size_value) == (guint)filestat.st_size))
changed = FALSE;
else {
if (row->size_value)
gda_value_free (row->size_value);
g_value_set_uint (row->size_value = gda_value_new (G_TYPE_UINT), filestat.st_size);
}
}
else {
if (row->size_value && gda_value_is_null (row->size_value))
changed = FALSE;
else {
if (row->size_value)
gda_value_free (row->size_value);
row->size_value = gda_value_new_null ();
}
}
return changed;
}
/*
* 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;
}
/**
* gda_select_alter_select_for_empty:
* @stmt: a SELECT #GdaStatement
* @error: (allow-none): a place to store errors, or %NULL
*
* Creates a new #GdaStatement, selecting the same data as @stmt, but which always returns an
* empty (no row) data model. This is use dy database providers' implementations.
*
* Returns: (transfer full): a new #GdaStatement
*/
GdaStatement *
gda_select_alter_select_for_empty (GdaStatement *stmt, G_GNUC_UNUSED GError **error)
{
GdaStatement *estmt;
GdaSqlStatement *sqlst;
GdaSqlStatementSelect *stsel;
g_assert (gda_statement_get_statement_type (stmt) == GDA_SQL_STATEMENT_SELECT);
g_object_get (G_OBJECT (stmt), "structure", &sqlst, NULL);
g_assert (sqlst);
if (sqlst->sql) {
g_free (sqlst->sql);
sqlst->sql = NULL;
}
stsel = (GdaSqlStatementSelect*) sqlst->contents;
/* set the WHERE condition to "1 = 0" */
GdaSqlExpr *expr, *cond = stsel->where_cond;
GdaSqlOperation *op;
if (cond)
gda_sql_expr_free (cond);
cond = gda_sql_expr_new (GDA_SQL_ANY_PART (stsel));
stsel->where_cond = cond;
op = gda_sql_operation_new (GDA_SQL_ANY_PART (cond));
cond->cond = op;
op->operator_type = GDA_SQL_OPERATOR_TYPE_EQ;
expr = gda_sql_expr_new (GDA_SQL_ANY_PART (op));
op->operands = g_slist_prepend (NULL, expr);
g_value_set_int ((expr->value = gda_value_new (G_TYPE_INT)), 1);
expr = gda_sql_expr_new (GDA_SQL_ANY_PART (op));
op->operands = g_slist_prepend (op->operands, expr);
g_value_set_int ((expr->value = gda_value_new (G_TYPE_INT)), 0);
/* replace any selected field which has a parameter with NULL */
gda_sql_any_part_foreach (GDA_SQL_ANY_PART (stsel), (GdaSqlForeachFunc) param_to_null_foreach,
NULL, NULL);
/* create new statement */
estmt = g_object_new (GDA_TYPE_STATEMENT, "structure", sqlst, NULL);
gda_sql_statement_free (sqlst);
return estmt;
}
static void
__add_second_dummy_constraint (GdaSqlStatementSelect *select, GdaSqlOperation *top_operation)
{
GdaSqlExpr *dexpr = gda_sql_expr_new (GDA_SQL_ANY_PART (top_operation));
dexpr->value = gda_value_new (G_TYPE_STRING);
g_value_take_string (dexpr->value, g_strdup ("0<1"));
top_operation->operands = g_slist_append (top_operation->operands, dexpr);
return;
}
/**
* gdaui_provider_selector_set_provider:
* @selector: a #GdauiProviderSelector widget
* @provider: (allow-none): the provider to be selected, or %NULL for the default (SQLite)
*
* Forces @selector to be set on @provider
*
* Returns: %TRUE if @provider has been selected
*
* Since: 4.2
*/
gboolean
gdaui_provider_selector_set_provider (GdauiProviderSelector *selector, const gchar *provider)
{
GSList *list;
gboolean retval;
GValue *tmpval;
g_return_val_if_fail (GDAUI_IS_PROVIDER_SELECTOR (selector), FALSE);
if (provider && *provider)
g_value_set_string (tmpval = gda_value_new (G_TYPE_STRING), provider);
else
g_value_set_string (tmpval = gda_value_new (G_TYPE_STRING), "SQLite");
list = g_slist_append (NULL, tmpval);
retval = _gdaui_combo_set_selected_ext (GDAUI_COMBO (selector), list, cols);
gda_value_free ((GValue *)(list->data));
g_slist_free (list);
return retval;
}
/*
* assign_parameters_values
*
* Tries to assign a value for each parameter in @plist, from the context
*
* Returns: TRUE on success
*/
static gboolean
assign_parameters_values (GdaReportEngine *engine, RunContext *context, GdaSet *plist, GError **error)
{
if (plist) {
GSList *list;
for (list = plist->holders; list; list = list->next) {
GdaHolder *source_param;
source_param = run_context_find_param (engine, context,
BAD_CAST gda_holder_get_id (GDA_HOLDER (list->data)));
if (!source_param) {
g_set_error (error, 0, 0,
_("Unknown parameter '%s'"),
gda_holder_get_id (GDA_HOLDER (list->data)));
return FALSE;
}
gda_holder_set_not_null (GDA_HOLDER (list->data), FALSE);
GType ptype, source_ptype;
ptype = gda_holder_get_g_type (GDA_HOLDER (list->data));
source_ptype = gda_holder_get_g_type (source_param);
if (ptype == source_ptype) {
if (! gda_holder_set_bind (GDA_HOLDER (list->data), source_param, error))
return FALSE;
}
else {
const GValue *source_value;
source_value = gda_holder_get_value (source_param);
if (source_value && !gda_value_is_null (source_value)) {
GValue *trans;
trans = gda_value_new (ptype);
if (g_value_transform (source_value, trans)) {
if (! gda_holder_set_value (GDA_HOLDER (list->data), trans, error)) {
gda_value_free (trans);
return FALSE;
}
gda_value_free (trans);
}
else {
gda_value_free (trans);
g_set_error (error, 0, 0,
_("Cannot cast parameter from type '%s' to type '%s'"),
g_type_name (source_ptype), g_type_name (ptype));
return FALSE;
}
}
else
if (! gda_holder_set_value (GDA_HOLDER (list->data), NULL, error))
return FALSE;
}
}
}
return TRUE;
}
static void
__add_exclude_deleted_constraints (MidgardQueryExecutor *self, GdaSqlStatementSelect *select, GdaSqlOperation *operation, MidgardDBObjectClass *dbklass)
{
GSList *l = select->from->targets;
const gchar *deleted_field = midgard_core_object_get_deleted_field (dbklass);
gboolean bool_is_int = MIDGARD_QUERY_EXECUTOR (self)->priv->bool_is_int;
/* We have only one target table, so create one expression and add to top operation */
if (g_slist_length (l) == 1) {
if (!deleted_field)
return;
GdaSqlSelectTarget *target = (GdaSqlSelectTarget *) l->data;
GdaSqlExpr *expr = gda_sql_expr_new (GDA_SQL_ANY_PART (operation));
expr->value = gda_value_new (G_TYPE_STRING);
g_value_take_string (expr->value, g_strdup_printf ("%s.%s = %s", target->as, deleted_field, __BOOL_VALUE (bool_is_int)));
operation->operands = g_slist_append (operation->operands, expr);
return;
}
/* Create new constraint group, (t1.deleted AND t2.deleted AND ...) */
GdaSqlExpr *deleted_expr = gda_sql_expr_new (GDA_SQL_ANY_PART (operation));
GdaSqlOperation *deleted_operation = gda_sql_operation_new (GDA_SQL_ANY_PART (deleted_expr));
deleted_operation->operator_type = GDA_SQL_OPERATOR_TYPE_AND;
deleted_expr->cond = deleted_operation;
operation->operands = g_slist_append (operation->operands, deleted_expr);
/* FIXME, we do not have own klass list involved in query */
/* Add metadata_deleted constraint for each statement's table */
for (l = select->from->targets; l != NULL; l = l->next) {
GdaSqlSelectTarget *target = (GdaSqlSelectTarget *) l->data;
GdaSqlExpr *expr = gda_sql_expr_new (GDA_SQL_ANY_PART (operation));
expr->value = gda_value_new (G_TYPE_STRING);
g_value_take_string (expr->value, g_strdup_printf ("%s.metadata_deleted = %s", target->as, __BOOL_VALUE (bool_is_int)));
deleted_operation->operands = g_slist_append (deleted_operation->operands, expr);
}
}
/**
* gda_column_set_description:
* @column: a #GdaColumn.
* @title: title name.
*
* Sets the column's description
*/
void
gda_column_set_description (GdaColumn *column, const gchar *descr)
{
GValue *value = NULL;
g_return_if_fail (GDA_IS_COLUMN (column));
if (descr)
g_value_set_string ((value = gda_value_new (G_TYPE_STRING)), descr);
gda_column_set_attribute_static (column, GDA_ATTRIBUTE_DESCRIPTION, value);
if (value)
gda_value_free (value);
}
void
__exclude_deleted_constraint (MidgardCRCoreQueryExecutor *executor, const gchar *table_alias)
{
GdaSqlStatement *sql_stm = executor->priv->stmt;
GdaSqlStatementSelect *select = (GdaSqlStatementSelect *) sql_stm->contents;
GdaSqlExpr *where = select->where_cond;
GdaSqlOperation *operation = where->cond;
GdaSqlExpr *expr = gda_sql_expr_new (GDA_SQL_ANY_PART (operation));
expr->value = gda_value_new (G_TYPE_STRING);
g_value_set_string (expr->value, "t1.metadata_deleted = 0");
operation->operands = g_slist_append (operation->operands, expr);
}
static GdaDataModel *
table_parameters_describe (const gchar *base_dn, const gchar *filter, const gchar *attributes,
GdaLdapSearchScope scope)
{
GdaDataModel *array;
GValue *v1, *v2;
GList *list;
array = gda_data_model_array_new_with_g_types (2, G_TYPE_STRING,
G_TYPE_STRING);
gda_data_model_set_column_title (array, 0, _("Parameter"));
gda_data_model_set_column_title (array, 1, _("Value"));
g_value_set_string ((v1 = gda_value_new (G_TYPE_STRING)), "BASE");
g_value_set_string ((v2 = gda_value_new (G_TYPE_STRING)), base_dn);
list = g_list_append (NULL, v1);
list = g_list_append (list, v2);
gda_data_model_append_values (array, list, NULL);
g_list_free (list);
gda_value_free (v1);
gda_value_free (v2);
g_value_set_string ((v1 = gda_value_new (G_TYPE_STRING)), "FILTER");
g_value_set_string ((v2 = gda_value_new (G_TYPE_STRING)), filter);
list = g_list_append (NULL, v1);
list = g_list_append (list, v2);
gda_data_model_append_values (array, list, NULL);
g_list_free (list);
gda_value_free (v1);
gda_value_free (v2);
g_value_set_string ((v1 = gda_value_new (G_TYPE_STRING)), "ATTRIBUTES");
g_value_set_string ((v2 = gda_value_new (G_TYPE_STRING)), attributes);
list = g_list_append (NULL, v1);
list = g_list_append (list, v2);
gda_data_model_append_values (array, list, NULL);
g_list_free (list);
gda_value_free (v1);
gda_value_free (v2);
g_value_set_string ((v1 = gda_value_new (G_TYPE_STRING)), "SCOPE");
g_value_set_string ((v2 = gda_value_new (G_TYPE_STRING)), scope_to_string (scope));
list = g_list_append (NULL, v1);
list = g_list_append (list, v2);
gda_data_model_append_values (array, list, NULL);
g_list_free (list);
gda_value_free (v1);
gda_value_free (v2);
return array;
}
static void
gdaui_provider_selector_show (GtkWidget *widget)
{
GSList *list;
GValue *tmpval;
GdauiProviderSelector *selector;
selector = (GdauiProviderSelector *) widget;
GTK_WIDGET_CLASS (parent_class)->show (widget);
g_value_set_string (tmpval = gda_value_new (G_TYPE_STRING), "SQLite");
list = g_slist_append (NULL, tmpval);
_gdaui_combo_set_selected_ext (GDAUI_COMBO (selector), list, cols);
gda_value_free ((GValue *)(list->data));
g_slist_free (list);
}
/* Returns: TRUE if FileRow value has been changed */
static gboolean
update_file_mime (FileRow *row, const gchar *complete_filename)
{
gboolean changed = TRUE;
GValue *value = NULL;
#ifdef HAVE_GIO
GFile *file;
GFileInfo *info;
file = g_file_new_for_path (complete_filename);
info = g_file_query_info (file,
G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE,
G_FILE_QUERY_INFO_NONE, NULL, NULL);
if (info) {
value = gda_value_new (G_TYPE_STRING);
g_value_set_string (value, g_file_info_get_content_type (info));
g_object_unref (info);
}
else
value = gda_value_new_null ();
g_object_unref (file);
#else
value = gda_value_new_null ();
#endif
if (value) {
if (row->mime_value && (G_VALUE_TYPE (row->mime_value) == G_TYPE_STRING)
&& !gda_value_compare (row->mime_value, value))
changed = FALSE;
else {
if (row->mime_value)
gda_value_free (row->mime_value);
row->mime_value = value;
}
}
else {
if (row->mime_value && gda_value_is_null (row->mime_value))
changed = FALSE;
else {
if (row->mime_value)
gda_value_free (row->mime_value);
row->mime_value = gda_value_new_null ();
}
}
return changed;
}
static gboolean
timout_cb (GdaTreeNode *node)
{
const GValue *cvalue;
GValue *scale;
gdouble sc;
cvalue = gda_tree_node_get_node_attribute (node, "scale");
g_assert (cvalue && (G_VALUE_TYPE (cvalue) == G_TYPE_DOUBLE));
sc = g_value_get_double (cvalue);
sc += 0.005;
if (sc > 1.2)
sc = .8;
g_value_set_double ((scale = gda_value_new (G_TYPE_DOUBLE)), sc);
gda_tree_node_set_node_attribute (node, "scale", scale, NULL);
gda_value_free (scale);
return TRUE;
}
static gboolean
param_to_null_foreach (GdaSqlAnyPart *part, G_GNUC_UNUSED gpointer data, G_GNUC_UNUSED GError **error)
{
if (part->type == GDA_SQL_ANY_EXPR) {
GdaSqlExpr *expr = (GdaSqlExpr*) part;
if (expr->param_spec) {
GType type = expr->param_spec->g_type;
gda_sql_param_spec_free (expr->param_spec);
expr->param_spec = NULL;
if (!expr->value) {
if (type != GDA_TYPE_NULL)
expr->value = gda_value_new_from_string ("0", type);
else
g_value_set_int ((expr->value = gda_value_new (G_TYPE_INT)), 0);
}
}
}
return TRUE;
}
gboolean
wmud_db_update_player_password(WmudPlayer *player,
gchar *crypted_password,
GError **err)
{
GValue *cpw,
*player_id;
GError *local_err = NULL;
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
"Saving player password for %s",
wmud_player_get_player_name(player));
if (dbh == NULL) {
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
"Database backend not initialized");
return FALSE;
}
player_id = gda_value_new(G_TYPE_UINT);
g_value_set_uint(player_id, wmud_player_get_id(player));
cpw = gda_value_new_from_string(crypted_password, G_TYPE_STRING);
if (!gda_connection_update_row_in_table(dbh,
"players",
"id", player_id,
&local_err,
"password", cpw,
NULL)) {
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_BADQUERY,
"Error saving player password: %s",
local_err->message);
return FALSE;
}
return TRUE;
}
/**
* gda_column_set_name:
* @column: a #GdaColumn.
* @name: the new name of @column.
*
* Sets the name of @column to @name.
*/
void
gda_column_set_name (GdaColumn *column, const gchar *name)
{
gchar *old_name = NULL;
GValue *value = NULL;
g_return_if_fail (GDA_IS_COLUMN (column));
old_name = (gchar *) gda_column_get_name (column);
if (old_name)
old_name = g_strdup (old_name);
if (name)
g_value_set_string ((value = gda_value_new (G_TYPE_STRING)), name);
gda_column_set_attribute_static (column, GDA_ATTRIBUTE_NAME, value);
if (value)
gda_value_free (value);
g_signal_emit (G_OBJECT (column),
gda_column_signals[NAME_CHANGED],
0, old_name);
g_free (old_name);
}
gboolean __query_select_add_joins (MidgardQuerySelect *self, GdaSqlOperation *operation, GError **error)
{
__add_implicit_workspace_join (self, operation);
if (!MIDGARD_QUERY_EXECUTOR (self)->priv->joins)
return TRUE;
GSList *l = NULL;
MidgardQueryExecutor *executor = MIDGARD_QUERY_EXECUTOR (self);
GdaSqlStatement *sql_stm = executor->priv->stmt;
GdaSqlStatementSelect *select = (GdaSqlStatementSelect *) sql_stm->contents;
GdaSqlSelectFrom *from = select->from;
GdaSqlSelectJoin *join;
for (l = MIDGARD_QUERY_EXECUTOR (self)->priv->joins; l != NULL; l = l->next) {
qsj *_sj = (qsj*) l->data;
join = gda_sql_select_join_new (GDA_SQL_ANY_PART (from));
join->type = _sj->join_type;
MidgardQueryStorage *left_storage = _sj->left_property->priv->storage;
MidgardQueryStorage *right_storage = _sj->right_property->priv->storage;
GError *err = NULL;
GValue lval = {0, };
midgard_query_holder_get_value (MIDGARD_QUERY_HOLDER (_sj->left_property), &lval);
gchar *left_table_field =
midgard_core_query_compute_constraint_property (executor, left_storage, g_value_get_string (&lval), &err);
if (err) {
g_propagate_error (error, err);
g_free (left_table_field);
}
GValue rval = {0, };
midgard_query_holder_get_value (MIDGARD_QUERY_HOLDER (_sj->right_property), &rval);
gchar *right_table_field =
midgard_core_query_compute_constraint_property (executor, right_storage, g_value_get_string (&rval), &err);
if (err) {
g_propagate_error (error, err);
g_free (right_table_field);
}
GdaSqlExpr *expr = gda_sql_expr_new (GDA_SQL_ANY_PART (join));
expr->value = gda_value_new (G_TYPE_STRING);
g_value_take_string (expr->value, g_strdup_printf ("%s = %s", left_table_field, right_table_field));
join->expr = expr;
join->position = ++executor->priv->joinid;
/* Add right storage to targets */
MQE_SET_TABLE_ALIAS (executor, right_storage);
gda_sql_select_from_take_new_join (from , join);
GdaSqlSelectTarget *s_target = gda_sql_select_target_new (GDA_SQL_ANY_PART (from));
s_target->table_name = g_strdup (right_storage->priv->table);
s_target->as = g_strdup (right_storage->priv->table_alias);
gda_sql_select_from_take_new_target (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, right_storage->priv->table);
texpr->value = tval;
s_target->expr = texpr;
}
return TRUE;
}
/*
* COMMAND: <gda_report_if>
*
* Creates a copy of the children of the <gda_report_if_true> or <gda_report_if_false> nodes depending on the
* result of the execution of the expression
*
* uses node's contents: yes
* requested attributes: none
*/
static gboolean
command_gda_report_if (GdaReportEngine *engine, xmlNodePtr node, GSList **created_nodes,
RunContext *context, GError **error)
{
GValue *value;
gboolean expr_is_true = FALSE;
xmlChar *prop;
prop = xmlGetProp (node, BAD_CAST "expr");
if (!prop) {
g_set_error (error, 0, 0, "%s",
_("No expression specified"));
return FALSE;
}
/* evaluate expression as boolean */
value = evaluate_expression (engine, context,
(const gchar *) prop, error);
if (!value)
return FALSE;
xmlFree (prop);
if (value && !gda_value_is_null (value)) {
if (G_VALUE_TYPE (value) == G_TYPE_BOOLEAN)
expr_is_true = g_value_get_boolean (value);
else {
GValue *trans;
trans = gda_value_new (G_TYPE_BOOLEAN);
if (g_value_transform (value, trans)) {
expr_is_true = g_value_get_boolean (trans);
gda_value_free (trans);
}
else {
gda_value_free (trans);
g_set_error (error, 0, 0,
_("Cannot cast value from type '%s' to type '%s'"),
g_type_name (G_VALUE_TYPE (value)), g_type_name (G_TYPE_BOOLEAN));
return FALSE;
}
}
gda_value_free (value);
}
/*g_print ("IF Expression evaluates to %d\n", expr_is_true);*/
/* find the correct sub node: <gda_report_if_true> or <gda_report_if_false> */
gchar *sub_node_name;
xmlNodePtr sub_node;
sub_node_name = expr_is_true ? "gda_report_if_true" : "gda_report_if_false";
for (sub_node = node->children; sub_node; sub_node = sub_node->next) {
if (!strcmp ((gchar *) sub_node->name, sub_node_name)) {
if (!real_run_at_node (engine, sub_node->children, context, error))
return FALSE;
else {
xmlNodePtr child;
for (child = sub_node->children; child; child = sub_node->children) {
xmlUnlinkNode (child);
*created_nodes = g_slist_prepend (*created_nodes, child);
}
}
}
}
*created_nodes = g_slist_reverse (*created_nodes);
return TRUE;
}
static void
__add_implicit_workspace_join (MidgardQuerySelect *self, GdaSqlOperation *operation)
{
g_return_if_fail (self != NULL);
MidgardDBObjectClass *klass = MIDGARD_QUERY_EXECUTOR (self)->priv->storage->priv->klass;
if (!g_type_is_a (G_OBJECT_CLASS_TYPE (klass), MIDGARD_TYPE_OBJECT))
return;
MidgardConnection *mgd = MIDGARD_QUERY_EXECUTOR (self)->priv->mgd;
/* Do not take worskpace into account if if it's disabled
* or enabled and none set */
if (!MGD_CNC_USES_WORKSPACE (mgd))
return;
if (!MGD_CNC_HAS_WORKSPACE (mgd))
return;
gboolean bool_is_int = MIDGARD_QUERY_EXECUTOR (self)->priv->bool_is_int;
guint ws_id = MGD_CNC_WORKSPACE_ID (mgd);
MidgardQueryExecutor *executor = MIDGARD_QUERY_EXECUTOR (self);
GdaSqlStatement *sql_stm = executor->priv->stmt;
GdaSqlStatementSelect *select = (GdaSqlStatementSelect *) sql_stm->contents;
GdaSqlSelectFrom *from = select->from;
GdaSqlSelectJoin *join;
const gchar *klass_table = MGD_DBCLASS_TABLENAME (klass);
gchar *left_table = executor->priv->table_alias;
//gchar *right_table = g_strdup_printf ("t%d", ++executor->priv->tableid);
gchar *right_table = g_strdup ("midgard_ws_tmp_table");
join = gda_sql_select_join_new (GDA_SQL_ANY_PART (from));
join->type = GDA_SQL_SELECT_JOIN_INNER;
GdaSqlExpr *expr = gda_sql_expr_new (GDA_SQL_ANY_PART (join));
expr->value = gda_value_new (G_TYPE_STRING);
g_value_take_string (expr->value, g_strdup_printf ("%s.%s = %s.%s",
left_table, MGD_WORKSPACE_ID_FIELD, right_table, MGD_WORKSPACE_ID_FIELD));
join->expr = expr;
join->position = ++executor->priv->joinid;
MidgardConfig *config = mgd->priv->config;
const gchar *sql_part_bool_func_start = "";
const gchar *sql_part_bool_func_end = "";
const gchar *deleted_field = midgard_core_object_get_deleted_field (klass);
GString *table = g_string_new ("(SELECT DISTINCT MAX");
if (config->priv->dbtype == MIDGARD_DB_TYPE_POSTGRES && deleted_field) {
sql_part_bool_func_start = " bool_or(";
sql_part_bool_func_end = ") AS metadata_deleted";
}
g_string_append_printf (table, "(%s) AS %s, %s %s%s%s%s FROM %s WHERE %s IN (0,",
MGD_WORKSPACE_ID_FIELD, MGD_WORKSPACE_ID_FIELD, MGD_WORKSPACE_OID_FIELD,
deleted_field ? "," : "",
sql_part_bool_func_start,
deleted_field ? deleted_field : "",
sql_part_bool_func_end,
klass_table, MGD_WORKSPACE_ID_FIELD);
const MidgardWorkspaceStorage *ws = midgard_connection_get_workspace (mgd);
GSList *list = MIDGARD_WORKSPACE_STORAGE_GET_INTERFACE (ws)->priv->list_ids (mgd, MIDGARD_WORKSPACE_STORAGE (ws));
GSList *l = NULL;
guint i = 0;
guint id;
for (l = list; l != NULL; l = l->next, i++) {
GValue *id_val = (GValue *) l->data;
if (G_VALUE_HOLDS_UINT (id_val))
id = g_value_get_uint (id_val);
else
id = (guint) g_value_get_int (id_val);
g_string_append_printf (table, "%s%d", i > 0 ? "," : "", id);
}
if (!list)
g_string_append (table, "0");
g_string_append (table, ") ");
if (deleted_field)
g_string_append_printf (table, "AND %s = %s ", deleted_field, __BOOL_VALUE (bool_is_int));
g_string_append_printf (table, "GROUP BY %s)", MGD_WORKSPACE_OID_FIELD);
g_slist_free (list);
gda_sql_select_from_take_new_join (from , join);
GdaSqlSelectTarget *s_target = gda_sql_select_target_new (GDA_SQL_ANY_PART (from));
s_target->table_name = g_string_free (table, FALSE);
s_target->as = right_table;
gda_sql_select_from_take_new_target (from, s_target);
/* MIDGARD_QUERY_EXECUTOR (self)->priv->include_deleted_targets =
g_slist_append (MIDGARD_QUERY_EXECUTOR (self)->priv->include_deleted_targets, s_target); */
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, g_strdup (s_target->table_name));
texpr->value = tval;
s_target->expr = texpr;
/* Add workspace object id constraint */
GdaSqlExpr *ws_expr = gda_sql_expr_new (GDA_SQL_ANY_PART (operation));
ws_expr->value = gda_value_new (G_TYPE_STRING);
g_value_take_string (ws_expr->value, g_strdup_printf ("%s.%s = %s.%s",
left_table, MGD_WORKSPACE_OID_FIELD, right_table, MGD_WORKSPACE_OID_FIELD));
operation->operands = g_slist_append (operation->operands, ws_expr);
}
void
_midgard_query_constraint_add_conditions_to_statement (MidgardQueryExecutor *executor, MidgardQueryConstraintSimple *constraint_simple, GdaSqlStatement *stmt, GdaSqlExpr *where_expr_node)
{
MidgardQueryConstraint *self = MIDGARD_QUERY_CONSTRAINT (constraint_simple);
//GdaConnection *cnc = executor->priv->mgd->priv->connection;
MidgardDBObjectClass *dbklass = NULL;
if (self->priv->storage && (self->priv->storage != MIDGARD_QUERY_EXECUTOR (executor)->priv->storage)) {
dbklass = self->priv->storage->priv->klass;
MQE_SET_TABLE_ALIAS (executor, self->priv->storage);
}
if (!dbklass)
dbklass = executor->priv->storage->priv->klass;
g_return_if_fail (dbklass != NULL);
/* Get table */
//const gchar *table = midgard_core_class_get_table (dbklass);
/* Get field name */
GValue field_value = {0, };
midgard_query_holder_get_value (MIDGARD_QUERY_HOLDER (MIDGARD_QUERY_CONSTRAINT (constraint_simple)->priv->property_value), &field_value);
GdaSqlStatementSelect *select = stmt->contents;
GdaSqlExpr *top_where, *where, *expr;
GdaSqlOperation *top_operation, *cond;
GValue *value;
if (where_expr_node) {
top_where = where_expr_node;
top_operation = top_where->cond;
} else {
top_where = select->where_cond;
top_operation = top_where->cond;
}
where = gda_sql_expr_new (GDA_SQL_ANY_PART (top_operation));
top_operation->operands = g_slist_append (top_operation->operands, where);
cond = gda_sql_operation_new (GDA_SQL_ANY_PART (where));
where->cond = cond;
cond->operator_type = self->priv->op_type;
/* Create table_alias.field name */
gchar *table_alias_field;
expr = gda_sql_expr_new (GDA_SQL_ANY_PART (cond));
table_alias_field = midgard_core_query_compute_constraint_property (executor,
MIDGARD_QUERY_CONSTRAINT (constraint_simple)->priv->storage, g_value_get_string (&field_value));
if (!table_alias_field)
g_warning ("Null table.field alias for given '%s'", g_value_get_string (&field_value));
/* TODO, handle error case when table_alias_field is NULL */
g_value_take_string ((value = gda_value_new (G_TYPE_STRING)), table_alias_field);
expr->value = value;
cond->operands = g_slist_append (cond->operands, expr);
expr = gda_sql_expr_new (GDA_SQL_ANY_PART (cond));
/* Create value */
GValue val = {0, };
midgard_query_holder_get_value (MIDGARD_QUERY_CONSTRAINT (constraint_simple)->priv->holder, &val);
/*GType v_type = G_VALUE_TYPE (&val);
//FIXME, create parameter name::type */
//GValue *dval = gda_value_new (G_TYPE_STRING);
//g_value_transform (&val, dval);
//expr->param_spec = gda_sql_param_spec_new (dval);
//expr->param_spec->g_type = v_type;
expr->value = gda_value_new (G_TYPE_STRING);
__set_expression_value (expr->value, &val);
g_value_unset (&val);
cond->operands = g_slist_append (cond->operands, expr);
/* increase executor's constraints number */
executor->priv->n_constraints++;
}
/**
* filter_editor_new:
*
* Returns: a new #GtkWidget
*/
GtkWidget *
filter_editor_new (TConnection *tcnc)
{
FilterEditor *feditor;
GtkWidget *grid, *label, *entry;
GdaDataModel *model;
GList *values;
GValue *v1, *v2;
g_return_val_if_fail (T_IS_CONNECTION (tcnc), NULL);
feditor = FILTER_EDITOR (g_object_new (FILTER_EDITOR_TYPE, NULL));
feditor->priv->tcnc = g_object_ref ((GObject*) tcnc);
grid = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (grid), 5);
gtk_box_pack_start (GTK_BOX (feditor), grid, TRUE, TRUE, 0);
label = gtk_label_new (_("Base DN:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
label = gtk_label_new (_("Filter expression:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
label = gtk_label_new (_("Attributes to fetch:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1);
label = gtk_label_new (_("Search scope:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1);
entry = gtk_entry_new ();
gtk_widget_set_hexpand (entry, TRUE);
gtk_grid_attach (GTK_GRID (grid), entry, 1, 0, 1, 1);
feditor->priv->base_dn = entry;
g_signal_connect (entry, "activate",
G_CALLBACK (activated_cb), feditor);
entry = gtk_entry_new ();
gtk_widget_set_hexpand (entry, TRUE);
gtk_grid_attach (GTK_GRID (grid), entry, 1, 1, 1, 1);
feditor->priv->filter = entry;
g_signal_connect (entry, "activate",
G_CALLBACK (activated_cb), feditor);
entry = gtk_entry_new ();
gtk_widget_set_hexpand (entry, TRUE);
gtk_grid_attach (GTK_GRID (grid), entry, 1, 2, 1, 1);
feditor->priv->attributes = entry;
g_signal_connect (entry, "activate",
G_CALLBACK (activated_cb), feditor);
model = gda_data_model_array_new_with_g_types (2, G_TYPE_INT, G_TYPE_STRING);
g_value_set_string ((v1 = gda_value_new (G_TYPE_STRING)), "Base (search the base DN only)");
values = g_list_prepend (NULL, v1);
g_value_set_int ((v2 = gda_value_new (G_TYPE_INT)), GDA_LDAP_SEARCH_BASE);
values = g_list_prepend (values, v2);
g_assert (gda_data_model_append_values (model, values, NULL) >= 0);
gda_value_free (v1);
gda_value_free (v2);
g_value_set_string ((v1 = gda_value_new (G_TYPE_STRING)), "Onelevel (search immediate children of base DN only)");
values = g_list_prepend (NULL, v1);
g_value_set_int ((v2 = gda_value_new (G_TYPE_INT)), GDA_LDAP_SEARCH_ONELEVEL);
values = g_list_prepend (values, v2);
g_assert (gda_data_model_append_values (model, values, NULL) >= 0);
gda_value_free (v1);
gda_value_free (v2);
g_value_set_string ((v1 = gda_value_new (G_TYPE_STRING)), "Subtree (search of the base DN and the entire subtree below)");
values = g_list_prepend (NULL, v1);
g_value_set_int ((v2 = gda_value_new (G_TYPE_INT)), GDA_LDAP_SEARCH_SUBTREE);
values = g_list_prepend (values, v2);
g_assert (gda_data_model_append_values (model, values, NULL) >= 0);
gda_value_free (v1);
gda_value_free (v2);
gint cols[] = {1};
entry = gdaui_combo_new_with_model (model, 1, cols);
gtk_widget_set_hexpand (entry, TRUE);
g_object_unref (model);
gtk_grid_attach (GTK_GRID (grid), entry, 1, 3, 1, 1);
feditor->priv->scope = entry;
filter_editor_clear (feditor);
gtk_widget_show_all (grid);
return (GtkWidget*) feditor;
}
int
main (int argc, char *argv[])
{
GdaConnection* connection;
GdaDataModel* data;
GError* error = NULL;
GValue *value;
gda_init();
error = NULL;
/* open connection to the SalesTest data source, using the GDA_CONNECTION_OPTIONS_THREAD_SAFE flag
* to make sure we can use the same connection from multiple threads at once */
connection = gda_connection_open_from_dsn ("SalesTest", NULL, GDA_CONNECTION_OPTIONS_THREAD_SAFE, &error);
if (!connection) {
fprintf (stderr, "%s\n", error->message);
return -1;
}
/* update meta data */
GdaThreadWrapper *wrapper;
guint job_id;
g_print ("Requesting a meta data update in the background.\n");
wrapper = gda_thread_wrapper_new ();
job_id = gda_thread_wrapper_execute (wrapper, (GdaThreadWrapperFunc) sub_thread_update_meta_store,
connection, NULL, &error);
if (job_id == 0) {
fprintf (stderr, "Can't use thread wrapper: %s\n", error->message);
return -1;
}
while (1) {
gboolean *result;
g_print ("Doing some business here...\n");
g_usleep (100000);
result = (gboolean *) gda_thread_wrapper_fetch_result (wrapper, FALSE, job_id, &error);
if (result) {
gboolean meta_ok;
g_object_unref (wrapper);
meta_ok = *result;
g_free (result);
if (!meta_ok) {
fprintf (stderr, "Could not update meta data: %s\n", error->message);
return -1;
}
g_print ("Meta data has been updated!\n");
break;
}
}
/*
* Get columns of the 'products' table
*/
g_value_set_string ((value = gda_value_new (G_TYPE_STRING)), "products");
data = gda_connection_get_meta_store_data (connection, GDA_CONNECTION_META_FIELDS, &error, 1,
"name", value);
if (!data)
return -1;
list_table_columns (data);
g_object_unref (data);
return 0;
}
/*
* gda_ldap_attr_value_to_g_value:
* Converts a #BerValue to a new #GValue
*
* Returns: a new #GValue, or %NULL on error
*/
GValue *
gda_ldap_attr_value_to_g_value (LdapConnectionData *cdata, GType type, BerValue *bv)
{
GValue *value = NULL;
if ((type == G_TYPE_DATE_TIME) ||
(type == G_TYPE_DATE)) {
/* see ftp://ftp.rfc-editor.org/in-notes/rfc4517.txt,
* section 3.3.13: Generalized Time
*/
GTimeVal tv;
gboolean conv;
if (! (conv = g_time_val_from_iso8601 (bv->bv_val,
&tv))) {
/* Add the 'T' char */
gchar *tmp, *str;
gint i, len;
str = bv->bv_val;
len = strlen (str);
if (len > 8) {
tmp = g_new (gchar, len + 2);
for (i = 0; i < 8; i++)
tmp[i] = str[i];
tmp [8] = 'T';
for (i = 9; str[i]; i++)
tmp[i] = str[i-1];
tmp[i] = 0;
conv = g_time_val_from_iso8601 (tmp, &tv);
g_free (tmp);
}
}
if (conv) {
struct tm *ptm;
#ifdef HAVE_LOCALTIME_R
struct tm tmpstm;
ptm = localtime_r (&(tv.tv_sec), &tmpstm);
#elif HAVE_LOCALTIME_S
struct tm tmpstm;
if (localtime_s (&tmpstm, &(tv.tv_sec)) == 0)
ptm = &tmpstm;
else
ptm = NULL;
#else
ptm = localtime (&(tv.tv_sec));
#endif
if (!ptm)
return NULL;
if (g_type_is_a (type, G_TYPE_DATE_TIME)) {
GTimeZone *tz = g_time_zone_new ("Z"); // UTC
GDateTime *ts = g_date_time_new (tz,
ptm->tm_year + 1900,
ptm->tm_mon + 1,
ptm->tm_mday,
ptm->tm_hour,
ptm->tm_min,
ptm->tm_sec);
value = gda_value_new (G_TYPE_DATE_TIME);
g_value_set_boxed (value, ts);
g_date_time_unref (ts);
}
else {
GDate *date;
date = g_date_new ();
g_date_set_time_val (date, &tv);
value = gda_value_new (type);
g_value_take_boxed (value, date);
}
}
}
else if (type == GDA_TYPE_BINARY) {
guchar *data;
data = g_new (guchar, bv->bv_len);
memcpy (data, bv->bv_val, sizeof (guchar) * bv->bv_len);
value = gda_value_new_binary (data, bv->bv_len);
}
else
value = gda_value_new_from_string (bv->bv_val, type);
return value;
}
static GSList *
gda_tree_mgr_xml_update_children (GdaTreeManager *manager, GdaTreeNode *node,
G_GNUC_UNUSED const GSList *children_nodes,
gboolean *out_error, GError **error)
{
GdaTreeMgrXml *mgr = GDA_TREE_MGR_XML (manager);
GSList *list = NULL;
xmlNodePtr xnode, child;
const GValue *cvalue;
cvalue = gda_tree_node_get_node_attribute (node, "xmlnode");
if (cvalue)
xnode = (xmlNodePtr) g_value_get_pointer (cvalue);
else
xnode = mgr->priv->root;
for (child = xnode->children; child; child = child->next) {
GString *string = NULL;
if (mgr->priv->attributes) {
gint i;
for (i = 0; ; i++) {
xmlChar *prop;
if (! mgr->priv->attributes[i])
break;
prop = xmlGetProp (child, BAD_CAST mgr->priv->attributes[i]);
if (!prop)
continue;
if (!string)
string = g_string_new ("");
else
g_string_append_c (string, ' ');
g_string_append_printf (string, "[%s=%s]", mgr->priv->attributes[i],
(gchar*) prop);
xmlFree (prop);
}
}
else {
/* use all attributes */
xmlAttrPtr attr;
for (attr = child->properties; attr; attr = attr->next) {
xmlChar *prop;
prop = xmlGetProp (child, attr->name);
if (!prop)
continue;
if (!string)
string = g_string_new ("");
else
g_string_append_c (string, ' ');
g_string_append_printf (string, "[%s=%s]", (gchar*) attr->name, (gchar*) prop);
xmlFree (prop);
}
}
if (string) {
GValue *xvalue;
GdaTreeNode* snode;
snode = gda_tree_manager_create_node (manager, node, string->str);
g_string_free (string, TRUE);
g_value_set_pointer ((xvalue = gda_value_new (G_TYPE_POINTER)), child);
gda_tree_node_set_node_attribute (snode, "xmlnode", xvalue, NULL);
gda_value_free (xvalue);
list = g_slist_prepend (list, snode);
}
}
return list;
}
