dataforge/graph_explorer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
graph_explorer/data.cpp
T
egutierrez c27d8e7ffc feat(0035e): Group hereda iconografia de hijos homogeneos 
apply_group_inherited_visuals(GraphData*, db_path) recorre los nodos
Group del grafo y, para cada uno, consulta los type_ref distintos de
sus hijos (entities con group_id apuntando al Group). Si todos
comparten un solo tipo, reasigna el type_id del Group al type_id de
ese tipo y fija shape_override = SHAPE_SQUARE para preservar el
cuadrado distintivo. Heterogeneo o sin hijos: el Group conserva su
visual generico (slate + ti-stack-2). Se invoca desde main.cpp y
reload_graph antes de apply_group_filter para que la reasignacion
sobreviva al compactado del array.
2026-05-04 14:21:01 +02:00

430 lines
17 KiB
C++
Raw Permalink Blame History

#include "data.h"
#include "../../../../cpp/vendor/sqlite3/sqlite3.h"
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
namespace ge {
// FNV1a-64 — debe coincidir con graph_sources.cpp y entity_ops.cpp para que
// los `user_data` calculados en este archivo casen con los del loader.
static uint64_t gf_fnv1a64(const char* s) {
uint64_t h = 1469598103934665603ULL;
for (; s && *s; ++s) {
h ^= (uint8_t)*s;
h *= 1099511628211ULL;
}
return h;
}
bool load_graph(const InputArgs& args, GraphData* out, graph::GraphLoadStats* stats) {
if (!out || !stats) return false;
*stats = graph::GraphLoadStats{};
if (!args.uri || !*args.uri) {
stats->errors = 1;
std::snprintf(stats->error_msg, sizeof(stats->error_msg),
"no input uri");
return false;
}
switch (args.kind) {
case INPUT_OPERATIONS:
return graph::graph_load_from_operations(args.uri, out, stats);
case INPUT_NONE:
default:
stats->errors = 1;
std::snprintf(stats->error_msg, sizeof(stats->error_msg),
"unsupported input kind");
return false;
}
}
bool reload_graph(const InputArgs& args, GraphData* out, graph::GraphLoadStats* stats,
const std::unordered_map<std::string, bool>* group_expanded) {
if (out) graph::graph_free(out);
bool ok = load_graph(args, out, stats);
if (!ok) return false;
if (args.uri && *args.uri) {
// Issue 0035e: heredar iconografia/color del tipo mayoritario de
// los hijos en cada Group homogeneo. Antes del filtro, asi el
// type_id reasignado se preserva en el array compactado.
apply_group_inherited_visuals(out, args.uri);
}
if (group_expanded && args.uri && *args.uri) {
// Best-effort: si falla la consulta de group_id, dejamos el grafo
// sin filtrar — el caller ya tiene un grafo valido.
apply_group_filter(out, args.uri, *group_expanded);
}
return true;
}
// ----------------------------------------------------------------------------
// apply_group_filter (issue 0035b)
// ----------------------------------------------------------------------------
namespace {
// Detecta si la columna `group_id` existe en `entities`. Sin la columna, el
// filtro no tiene nada que hacer y devuelve sin tocar el grafo. La migracion
// (issue 0035a) la anade en BDs nuevas y existentes; pero si por algun motivo
// abrimos una BD vieja antes de que migrate corra, no debemos petar.
bool has_group_id_column(sqlite3* db) {
sqlite3_stmt* st = nullptr;
if (sqlite3_prepare_v2(db, "PRAGMA table_info(entities)", -1, &st, nullptr) != SQLITE_OK)
return false;
bool found = false;
while (sqlite3_step(st) == SQLITE_ROW) {
const unsigned char* name = sqlite3_column_text(st, 1);
if (name && std::strcmp((const char*)name, "group_id") == 0) {
found = true;
break;
}
}
sqlite3_finalize(st);
return found;
}
// Detecta el nombre de la columna de tipo en entities (puede ser type_ref o
// type segun la version del schema).
std::string entity_type_column(sqlite3* db) {
sqlite3_stmt* st = nullptr;
if (sqlite3_prepare_v2(db, "PRAGMA table_info(entities)", -1, &st, nullptr) != SQLITE_OK)
return "type_ref";
std::string col = "type_ref";
bool seen_type_ref = false;
bool seen_type = false;
while (sqlite3_step(st) == SQLITE_ROW) {
const unsigned char* name = sqlite3_column_text(st, 1);
if (!name) continue;
if (std::strcmp((const char*)name, "type_ref") == 0) seen_type_ref = true;
if (std::strcmp((const char*)name, "type") == 0) seen_type = true;
}
sqlite3_finalize(st);
if (seen_type_ref) col = "type_ref";
else if (seen_type) col = "type";
return col;
}
} // anon
bool apply_group_filter(GraphData* g, const char* db_path,
const std::unordered_map<std::string, bool>& group_expanded) {
if (!g || !db_path || !*db_path) return false;
if (g->node_count <= 0) return true;
sqlite3* db = nullptr;
if (sqlite3_open(db_path, &db) != SQLITE_OK) {
if (db) sqlite3_close(db);
return false;
}
if (!has_group_id_column(db)) {
sqlite3_close(db);
return true; // schema antiguo: nada que filtrar
}
std::string type_col = entity_type_column(db);
// Lee (id, group_id, type) para todas las entidades. Construimos:
// - hash_to_entity_id: user_data (FNV1a64 del id) → string id
// - entity_to_group_id: id string → group_id string ("" si NULL)
// - is_group_type: id string → true si type == "Group"
std::unordered_map<uint64_t, std::string> hash_to_entity_id;
std::unordered_map<std::string, std::string> entity_to_group_id;
std::unordered_set<std::string> group_entities;
{
std::string q = "SELECT id, group_id, " + type_col + " FROM entities";
sqlite3_stmt* st = nullptr;
if (sqlite3_prepare_v2(db, q.c_str(), -1, &st, nullptr) != SQLITE_OK) {
sqlite3_close(db);
return false;
}
while (sqlite3_step(st) == SQLITE_ROW) {
const unsigned char* id_c = sqlite3_column_text(st, 0);
const unsigned char* gid_c = sqlite3_column_text(st, 1);
const unsigned char* tp_c = sqlite3_column_text(st, 2);
if (!id_c) continue;
std::string id_s = (const char*)id_c;
std::string gid_s = gid_c ? (const char*)gid_c : "";
std::string type_s = tp_c ? (const char*)tp_c : "";
hash_to_entity_id[gf_fnv1a64(id_s.c_str())] = id_s;
if (!gid_s.empty()) entity_to_group_id[id_s] = gid_s;
if (type_s == "Group") group_entities.insert(id_s);
}
sqlite3_finalize(st);
}
sqlite3_close(db);
// Helper: devuelve true si el entity_id `eid` es un grupo expandido.
auto is_expanded = [&](const std::string& eid) -> bool {
auto it = group_expanded.find(eid);
return it != group_expanded.end() && it->second;
};
// Para cada nodo del grafo, decidir:
// - hidden: se elimina del array final
// - effective_node_idx: indice del nodo en el array nuevo, o -1 si oculto
// - redirect_to_group_idx: si oculto y su grupo existe en el grafo y NO
// esta expandido, las aristas se redirigen al indice del grupo en el
// array nuevo. Si el grupo no existe en el grafo (orfano), se deja -1
// y las aristas se descartan.
// Construimos primero un map hash→old_idx y entity_id→old_idx para
// resolver rapido los grupos.
std::unordered_map<std::string, int> entity_id_to_old_idx;
entity_id_to_old_idx.reserve((size_t)g->node_count);
for (int i = 0; i < g->node_count; ++i) {
auto it = hash_to_entity_id.find(g->nodes[i].user_data);
if (it != hash_to_entity_id.end()) {
entity_id_to_old_idx[it->second] = i;
}
}
// Decidir visibility por nodo.
std::vector<unsigned char> hidden((size_t)g->node_count, 0);
std::vector<int> redirect_old(g->node_count, -1); // old_idx → old_idx del grupo (si oculto)
for (int i = 0; i < g->node_count; ++i) {
auto hit = hash_to_entity_id.find(g->nodes[i].user_data);
if (hit == hash_to_entity_id.end()) continue;
const std::string& eid = hit->second;
auto git = entity_to_group_id.find(eid);
if (git == entity_to_group_id.end()) continue;
const std::string& parent = git->second;
if (is_expanded(parent)) continue; // grupo expandido → visible
// Nodo oculto. Buscar el indice del grupo padre en el grafo.
auto pit = entity_id_to_old_idx.find(parent);
if (pit != entity_id_to_old_idx.end()) {
redirect_old[i] = pit->second;
hidden[i] = 1;
} else {
// Grupo padre no presente en el grafo cargado — ocultamos sin
// redirigir. Las aristas se descartan.
hidden[i] = 1;
}
}
// Compactar nodos: nuevo array sin los ocultos. Mantenemos un map old→new.
std::vector<int> old_to_new((size_t)g->node_count, -1);
int new_count = 0;
for (int i = 0; i < g->node_count; ++i) {
if (hidden[i]) continue;
old_to_new[i] = new_count;
if (new_count != i) g->nodes[new_count] = g->nodes[i];
++new_count;
}
int original_node_count = g->node_count;
g->node_count = new_count;
// Helper: dado old_idx, devuelve el new_idx efectivo (redirige al grupo
// si oculto). Devuelve -1 si imposible (oculto sin grupo en el grafo).
auto effective_new_idx = [&](int old_idx) -> int {
if (old_idx < 0 || old_idx >= original_node_count) return -1;
if (!hidden[old_idx]) return old_to_new[old_idx];
int g_old = redirect_old[old_idx];
if (g_old < 0) return -1;
return old_to_new[g_old]; // el grupo es siempre visible
};
// Filtrar/redirigir aristas.
// Para deduplicacion grupo-a-grupo: clave = (min(grp_old_a, grp_old_b),
// max(...), rel_type_id). Asi mantenemos UNA arista por par + tipo.
std::unordered_set<uint64_t> seen_grp_pairs;
auto pair_key = [](int a, int b, uint16_t rt) -> uint64_t {
if (a > b) std::swap(a, b);
// a, b en uint32 + rt en 16 bits. Combinamos.
uint64_t k = (uint64_t)(uint32_t)a;
k = (k << 24) ^ (uint64_t)(uint32_t)b;
k = (k << 16) ^ (uint64_t)rt;
return k;
};
int new_edge_count = 0;
for (int e = 0; e < g->edge_count; ++e) {
GraphEdge& edge = g->edges[e];
int s_old = (int)edge.source;
int t_old = (int)edge.target;
if (s_old < 0 || s_old >= original_node_count ||
t_old < 0 || t_old >= original_node_count) continue;
bool s_hidden = hidden[s_old] != 0;
bool t_hidden = hidden[t_old] != 0;
int s_new = effective_new_idx(s_old);
int t_new = effective_new_idx(t_old);
if (s_new < 0 || t_new < 0) continue; // descarte por orfandad
// Caso 1: ambos extremos eran hijos de grupo(s) colapsado(s).
if (s_hidden && t_hidden) {
// Si caen en el MISMO grupo → arista interna, se descarta
// (issue 0035 decision 5).
int s_grp_old = redirect_old[s_old];
int t_grp_old = redirect_old[t_old];
if (s_grp_old < 0 || t_grp_old < 0) continue;
if (s_grp_old == t_grp_old) continue;
// Distintos grupos → dedup por par + rel_type.
uint64_t k = pair_key(s_grp_old, t_grp_old, edge.type_id);
if (seen_grp_pairs.count(k)) continue;
seen_grp_pairs.insert(k);
edge.source = (uint32_t)s_new;
edge.target = (uint32_t)t_new;
}
else if (s_hidden || t_hidden) {
// Cross-edge: un extremo dentro de grupo colapsado, otro fuera.
// Redirigimos el extremo oculto al grupo. Sin dedup (issue 0035
// decision 5: una linea por arista cuando es single-cross).
edge.source = (uint32_t)s_new;
edge.target = (uint32_t)t_new;
}
else {
// Ambos visibles — arista normal.
edge.source = (uint32_t)s_new;
edge.target = (uint32_t)t_new;
}
if (new_edge_count != e) g->edges[new_edge_count] = edge;
++new_edge_count;
}
g->edge_count = new_edge_count;
g->update_bounds();
return true;
}
// ----------------------------------------------------------------------------
// apply_group_inherited_visuals (issue 0035e)
// ----------------------------------------------------------------------------
//
// Para cada nodo Group del grafo, consulta los `type_ref` distintos de sus
// hijos (entities con group_id apuntando al grupo). Si todos comparten un
// solo tipo (homogeneo), reasigna el `type_id` del nodo Group al type_id de
// ese tipo y fija `shape_override = SHAPE_SQUARE` para preservar la forma
// distintiva de contenedor. Asi el cuadrado adopta color e icono del tipo
// hijo. Si la familia es heterogenea o el tipo hijo no esta presente en
// graph.types[], el nodo conserva su visual generico (Group / slate).
//
// Idempotente: si la heredancia ya se aplico, vuelve a aplicar lo mismo.
// No-op si la BD no tiene group_id, o si no hay nodos Group.
bool apply_group_inherited_visuals(GraphData* g, const char* db_path) {
if (!g || !db_path || !*db_path) return false;
if (g->node_count <= 0 || g->type_count <= 0) return true;
sqlite3* db = nullptr;
if (sqlite3_open(db_path, &db) != SQLITE_OK) {
if (db) sqlite3_close(db);
return false;
}
if (!has_group_id_column(db)) {
sqlite3_close(db);
return true;
}
std::string type_col = entity_type_column(db);
// Localizar el type_id del tipo "Group" en graph.types[].
int group_type_id = -1;
for (int i = 0; i < g->type_count; ++i) {
const char* nm = g->types[i].name;
if (nm && (std::strcmp(nm, "Group") == 0 ||
std::strcmp(nm, "group") == 0)) {
group_type_id = i;
break;
}
}
if (group_type_id < 0) { sqlite3_close(db); return true; }
// user_data (FNV1a64 del id) → entity_id string, para resolver cada
// nodo Group del grafo a su id real en operations.db.
// Solo nos interesan los Group nodes — filtramos por type_id.
std::vector<std::pair<int, std::string>> group_nodes; // (node_idx, entity_id)
{
// Cargamos un map id→user_data inverso unico via consulta directa
// a operations.db (id texto → user_data). Mas barato: iterar el
// grafo + invertir hash via consulta.
// Construimos hash→id desde la BD (igual que apply_group_filter).
std::unordered_map<uint64_t, std::string> hash_to_id;
std::string q = "SELECT id FROM entities WHERE " + type_col + " = 'Group'";
sqlite3_stmt* st = nullptr;
if (sqlite3_prepare_v2(db, q.c_str(), -1, &st, nullptr) == SQLITE_OK) {
while (sqlite3_step(st) == SQLITE_ROW) {
const unsigned char* idc = sqlite3_column_text(st, 0);
if (!idc) continue;
std::string ids = (const char*)idc;
hash_to_id[gf_fnv1a64(ids.c_str())] = ids;
}
sqlite3_finalize(st);
}
for (int i = 0; i < g->node_count; ++i) {
// Solo nodos cuyo type_id resuelve a Group. Si la inheritance ya
// se aplico en una pasada previa, el type_id ya no es Group y
// el nodo se omite — idempotencia natural pero significa que
// si el set de hijos cambia, hace falta recargar el grafo.
if (g->nodes[i].type_id != (uint16_t)group_type_id) continue;
auto it = hash_to_id.find(g->nodes[i].user_data);
if (it != hash_to_id.end()) group_nodes.emplace_back(i, it->second);
}
}
if (group_nodes.empty()) { sqlite3_close(db); return true; }
// Para cada Group, contar type_refs distintos de sus hijos.
// Solo consideramos hijos con group_id == group.id Y type_ref != 'Group'
// (un Group hijo de otro Group seria meta-anidacion, fuera de scope).
std::string child_q =
"SELECT DISTINCT " + type_col + " FROM entities "
"WHERE group_id = ? AND " + type_col + " != 'Group'";
sqlite3_stmt* cst = nullptr;
if (sqlite3_prepare_v2(db, child_q.c_str(), -1, &cst, nullptr) != SQLITE_OK) {
sqlite3_close(db);
return false;
}
auto find_type_id_by_name = [&](const std::string& nm) -> int {
for (int i = 0; i < g->type_count; ++i) {
const char* tn = g->types[i].name;
if (!tn) continue;
// case-insensitive match
if (nm.size() != std::strlen(tn)) continue;
bool eq = true;
for (size_t k = 0; k < nm.size(); ++k) {
if (std::tolower((unsigned char)nm[k]) !=
std::tolower((unsigned char)tn[k])) { eq = false; break; }
}
if (eq) return i;
}
return -1;
};
for (auto& [node_idx, eid] : group_nodes) {
sqlite3_reset(cst);
sqlite3_clear_bindings(cst);
sqlite3_bind_text(cst, 1, eid.c_str(), -1, SQLITE_TRANSIENT);
std::string single_type;
bool homogeneous = true;
int distinct_count = 0;
while (sqlite3_step(cst) == SQLITE_ROW) {
const unsigned char* tc = sqlite3_column_text(cst, 0);
std::string t = tc ? (const char*)tc : "";
if (t.empty()) continue;
++distinct_count;
if (distinct_count == 1) single_type = t;
else if (t != single_type) { homogeneous = false; break; }
}
if (!homogeneous || distinct_count != 1) continue;
int new_type_id = find_type_id_by_name(single_type);
if (new_type_id < 0 || new_type_id == group_type_id) continue;
g->nodes[node_idx].type_id = (uint16_t)new_type_id;
g->nodes[node_idx].shape_override = SHAPE_SQUARE; // mantener cuadrado
}
sqlite3_finalize(cst);
sqlite3_close(db);
return true;
}
} // namespace ge
Reference in New Issue View Git Blame Copy Permalink