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 GSList *
gda_tree_mgr_select_update_children (GdaTreeManager *manager, GdaTreeNode *node,
G_GNUC_UNUSED const GSList *children_nodes, gboolean *out_error,
GError **error)
{
GdaTreeMgrSelect *mgr = GDA_TREE_MGR_SELECT (manager);
GdaDataModel *model;
GSList *list = NULL;
if (!mgr->priv->cnc) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No connection specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
if (!mgr->priv->stmt) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No SELECT statement specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
if (node && mgr->priv->non_bound_params) {
/* looking for values in @node's attributes */
GSList *nbplist;
for (nbplist = mgr->priv->non_bound_params; nbplist; nbplist = nbplist->next) {
const GValue *cvalue;
GdaHolder *holder = (GdaHolder*) nbplist->data;
cvalue = gda_tree_node_fetch_attribute (node, gda_holder_get_id (holder));
if (cvalue) {
if (!gda_holder_set_value (holder, cvalue, error)) {
if (out_error)
*out_error = TRUE;
return NULL;
}
}
else {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
_("No value specified for parameter '%s'"), gda_holder_get_id (holder));
if (out_error)
*out_error = TRUE;
return NULL;
}
}
}
model = gda_connection_statement_execute_select (mgr->priv->cnc, mgr->priv->stmt, mgr->priv->priv_params, error);
if (!model) {
if (out_error)
*out_error = TRUE;
return NULL;
}
GdaDataModelIter *iter;
iter = gda_data_model_create_iter (model);
for (; iter && gda_data_model_iter_move_next (iter);) {
GdaTreeNode* snode = NULL;
const GValue *cvalue;
GSList *iholders;
for (iholders = GDA_SET (iter)->holders; iholders; iholders = iholders->next) {
GdaHolder *holder = (GdaHolder*) iholders->data;
if (!gda_holder_is_valid (holder) || !(cvalue = gda_holder_get_value (holder))) {
if (list) {
g_slist_foreach (list, (GFunc) g_object_unref, NULL);
g_slist_free (list);
}
if (out_error)
*out_error = TRUE;
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("Unable to get iterator's value"));
return NULL;
}
if (!snode) {
gchar *str = gda_value_stringify (cvalue);
snode = gda_tree_manager_create_node (manager, node, str);
g_free (str);
list = g_slist_prepend (list, snode);
}
gda_tree_node_set_node_attribute (snode, g_strdup (gda_holder_get_id (holder)), cvalue, g_free);
}
}
if (iter)
g_object_unref (iter);
g_object_unref (model);
return list;
}
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;
}
static GSList *
gda_tree_mgr_columns_update_children (GdaTreeManager *manager, GdaTreeNode *node, G_GNUC_UNUSED const GSList *children_nodes,
gboolean *out_error, GError **error)
{
GdaTreeMgrColumns *mgr = GDA_TREE_MGR_COLUMNS (manager);
GdaMetaStore *store;
GdaDataModel *model;
GSList *list = NULL;
GdaConnection *scnc;
GdaTreeMgrColumnsPrivate *priv = gda_tree_mgr_columns_get_instance_private (mgr);
if (!priv->cnc && !priv->mstore) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No connection and no GdaMetaStore specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
else if (priv->mstore)
store = priv->mstore;
else
store = gda_connection_get_meta_store (priv->cnc);
scnc = gda_meta_store_get_internal_connection (store);
/* create statements if necessary */
if (!priv->stmt) {
GdaSqlParser *parser;
GdaStatement *stmt;
parser = gda_connection_create_parser (scnc);
if (! parser)
parser = gda_sql_parser_new ();
stmt = gda_sql_parser_parse_string (parser,
"SELECT column_name FROM _columns WHERE "
"table_schema= ##schema::string AND "
"table_name= ##table_name::string "
"ORDER BY ordinal_position", NULL, error);
g_object_unref (parser);
if (!stmt) {
if (out_error)
*out_error = TRUE;
return NULL;
}
if (!gda_statement_get_parameters (stmt, &(priv->params), error)) {
if (out_error)
*out_error = TRUE;
g_object_unref (stmt);
return NULL;
}
priv->stmt = stmt;
}
gboolean schema_specified = FALSE;
gboolean table_specified = FALSE;
if (priv->schema) {
schema_specified = TRUE;
g_assert (gda_set_set_holder_value (priv->params, NULL, "schema",
priv->schema));
}
if (priv->table_name) {
table_specified = TRUE;
g_assert (gda_set_set_holder_value (priv->params, NULL, "table_name",
priv->table_name));
}
if (!schema_specified && node) {
/* looking for a schema in @node's attributes */
const GValue *cvalue;
cvalue = gda_tree_node_fetch_attribute (node, "schema");
if (cvalue) {
GdaHolder *h = gda_set_get_holder (priv->params, "schema");
if (!gda_holder_set_value (h, cvalue, error)) {
if (out_error)
*out_error = TRUE;
return NULL;
}
schema_specified = TRUE;
}
}
if (!table_specified && node) {
/* looking for a table in @node's attributes */
const GValue *cvalue;
cvalue = gda_tree_node_fetch_attribute (node, "table_name");
if (cvalue) {
GdaHolder *h = gda_set_get_holder (priv->params, "table_name");
if (!gda_holder_set_value (h, cvalue, error)) {
if (out_error)
*out_error = TRUE;
return NULL;
}
table_specified = TRUE;
}
}
if (!schema_specified) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No schema specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
if (!table_specified) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No table specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
model = gda_connection_statement_execute_select (scnc, priv->stmt, priv->params, error);
if (!model) {
if (out_error)
*out_error = TRUE;
return NULL;
}
GdaDataModelIter *iter;
iter = gda_data_model_create_iter (model);
for (; iter && gda_data_model_iter_move_next (iter);) {
GdaTreeNode* snode;
const GValue *cvalue;
cvalue = gda_data_model_iter_get_value_at (iter, 0);
if (!cvalue) {
if (list) {
g_slist_free_full (list, (GDestroyNotify) g_object_unref);
}
if (out_error)
*out_error = TRUE;
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("Unable to get column name"));
return NULL;
}
snode = gda_tree_manager_create_node (manager, node, g_value_get_string (cvalue));
gda_tree_node_set_node_attribute (snode, "column_name", cvalue, NULL);
list = g_slist_prepend (list, snode);
}
if (iter)
g_object_unref (iter);
g_object_unref (model);
return list;
}
static GSList *
gda_tree_mgr_schemas_update_children (GdaTreeManager *manager, GdaTreeNode *node,
G_GNUC_UNUSED const GSList *children_nodes, gboolean *out_error,
GError **error)
{
GdaTreeMgrSchemas *mgr = GDA_TREE_MGR_SCHEMAS (manager);
GdaMetaStore *store;
GdaDataModel *model;
GSList *list = NULL;
GdaConnection *scnc;
if (!mgr->priv->cnc && !mgr->priv->mstore) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No connection and no GdaMetaStore specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
else if (mgr->priv->mstore)
store = mgr->priv->mstore;
else
store = gda_connection_get_meta_store (mgr->priv->cnc);
scnc = gda_meta_store_get_internal_connection (store);
if (!mgr->priv->stmt) {
GdaSqlParser *parser;
GdaStatement *stmt;
parser = gda_connection_create_parser (scnc);
if (! parser)
parser = gda_sql_parser_new ();
stmt = gda_sql_parser_parse_string (parser,
"SELECT schema_name FROM _schemata "
"WHERE schema_internal = FALSE OR schema_name LIKE 'info%' "
"ORDER BY schema_name DESC", NULL, error);
g_object_unref (parser);
if (!stmt) {
if (out_error)
*out_error = TRUE;
return NULL;
}
mgr->priv->stmt = stmt;
}
model = gda_connection_statement_execute_select (scnc, mgr->priv->stmt, NULL, error);
if (!model) {
if (out_error)
*out_error = TRUE;
return NULL;
}
GdaDataModelIter *iter;
iter = gda_data_model_create_iter (model);
for (; iter && gda_data_model_iter_move_next (iter);) {
GdaTreeNode* snode;
const GValue *cvalue;
cvalue = gda_data_model_iter_get_value_at (iter, 0);
if (!cvalue) {
if (list) {
g_slist_foreach (list, (GFunc) g_object_unref, NULL);
g_slist_free (list);
}
if (out_error)
*out_error = TRUE;
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("Unable to get schema name"));
return NULL;
}
snode = gda_tree_manager_create_node (manager, node, g_value_get_string (cvalue));
gda_tree_node_set_node_attribute (snode, "schema", cvalue, NULL);
list = g_slist_prepend (list, snode);
}
if (iter)
g_object_unref (iter);
g_object_unref (model);
return list;
}
static GSList *
mgr_columns_update_children (GdaTreeManager *manager, GdaTreeNode *node, const GSList *children_nodes,
gboolean *out_error, GError **error)
{
MgrColumns *mgr = MGR_COLUMNS (manager);
GSList *nodes_list = NULL;
GHashTable *ehash = NULL;
if (out_error)
*out_error = FALSE;
if (children_nodes)
ehash = hash_for_existing_nodes (children_nodes);
GdaMetaStruct *mstruct;
mstruct = t_connection_get_meta_struct (mgr->priv->tcnc);
if (!mstruct) {
g_set_error (error, MGR_COLUMNS_ERROR, MGR_COLUMNS_NO_META_STRUCT,
"%s", _("Not ready"));
if (out_error)
*out_error = TRUE;
return NULL;
}
GdaMetaDbObject *dbo;
GValue *schema_v = NULL, *name_v;
if (mgr->priv->schema)
g_value_set_string ((schema_v = gda_value_new (G_TYPE_STRING)), mgr->priv->schema);
g_value_set_string ((name_v = gda_value_new (G_TYPE_STRING)), mgr->priv->table_name);
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) {
g_set_error (error, MGR_COLUMNS_ERROR, MGR_COLUMNS_TABLE_NOT_FOUND,
"%s", _("Table not found"));
if (out_error)
*out_error = TRUE;
return NULL;
}
if ((dbo->obj_type != GDA_META_DB_TABLE) && (dbo->obj_type != GDA_META_DB_VIEW)) {
g_set_error (error, MGR_COLUMNS_ERROR, MGR_COLUMNS_WRONG_OBJ_TYPE,
"%s", _("Requested object is not a table or view"));
if (out_error)
*out_error = TRUE;
return NULL;
}
GdaMetaTable *dbotable;
GSList *columns;
gint index;
dbotable = GDA_META_TABLE (dbo);
for (columns = dbotable->columns, index = 0;
columns;
columns = columns->next, index ++) {
GdaMetaTableColumn *col;
col = GDA_META_TABLE_COLUMN (columns->data);
GdaTreeNode* snode = NULL;
GValue *av;
if (ehash)
snode = g_hash_table_lookup (ehash, col->column_name);
if (snode) {
/* use the same node */
g_object_ref (G_OBJECT (snode));
}
else {
/* column's name */
snode = gda_tree_manager_create_node (manager, node, NULL);
if (col->pkey)
g_value_take_string ((av = gda_value_new (G_TYPE_STRING)),
g_strdup_printf ("<b>%s</b>", col->column_name));
else
g_value_set_string ((av = gda_value_new (G_TYPE_STRING)), col->column_name);
gda_tree_node_set_node_attribute (snode, MGR_COLUMNS_COL_NAME_ATT_NAME, av, NULL);
gda_value_free (av);
}
/* column's type */
g_value_set_string ((av = gda_value_new (G_TYPE_STRING)), col->column_type);
gda_tree_node_set_node_attribute (snode, MGR_COLUMNS_COL_TYPE_ATT_NAME, av, NULL);
gda_value_free (av);
/* NOT NULL */
g_value_set_boolean ((av = gda_value_new (G_TYPE_BOOLEAN)), !col->nullok);
gda_tree_node_set_node_attribute (snode, MGR_COLUMNS_COL_NOTNULL_ATT_NAME, av, NULL);
gda_value_free (av);
/* default value */
g_value_set_string ((av = gda_value_new (G_TYPE_STRING)), col->default_value);
gda_tree_node_set_node_attribute (snode, MGR_COLUMNS_COL_DEFAULT_ATT_NAME, av, NULL);
gda_value_free (av);
/* icon */
UiIconType type = UI_ICON_COLUMN;
GdkPixbuf *pixbuf;
gboolean is_fk = column_is_fk_part (dbo, index);
if (col->pkey)
type = UI_ICON_COLUMN_PK;
else if (!col->nullok) {
if (is_fk)
type = UI_ICON_COLUMN_FK_NN;
else
type = UI_ICON_COLUMN_NN;
}
else if (is_fk)
type = UI_ICON_COLUMN_FK;
pixbuf = ui_get_pixbuf_icon (type);
av = gda_value_new (G_TYPE_OBJECT);
g_value_set_object (av, pixbuf);
gda_tree_node_set_node_attribute (snode, "icon", av, NULL);
gda_value_free (av);
/* details */
GString *details = NULL;
if (col->pkey)
details = g_string_new (_("Primary key"));
if (is_fk) {
if (details)
g_string_append (details, ", ");
else
details = g_string_new ("");
g_string_append (details, _("Foreign key"));
}
const GValue *autoinc;
autoinc = gda_meta_table_column_get_attribute (col, GDA_ATTRIBUTE_AUTO_INCREMENT);
if (autoinc) {
if (details)
g_string_append (details, ", ");
else
details = g_string_new ("");
g_string_append (details, _("Auto incremented"));
}
if (details) {
g_value_set_string ((av = gda_value_new (G_TYPE_STRING)), details->str);
gda_tree_node_set_node_attribute (snode, MGR_COLUMNS_COL_DETAILS, av, NULL);
gda_value_free (av);
g_string_free (details, TRUE);
}
nodes_list = g_slist_prepend (nodes_list, snode);
}
if (ehash)
g_hash_table_destroy (ehash);
return g_slist_reverse (nodes_list);
}
