dataforge/graph_explorer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(table-node): DuckDB foundation + render colapsado (issue 0010)

Browse Source 
- tableview.{h,cpp}: capa C sobre DuckDB v1.1.3.
  * tableview_smoke_test (SELECT 42).
  * tableview_count (con sql_filter opcional).
  * tableview_page (LEFT JOIN sobre ops.entities via ATTACH para flag promoted).
  * tableview_create (inserta entidad type_ref='Table' con metadata pointer).
  * tableview_refresh_counts (lee Table entities, count cada DuckDB y cachea
    por user_data hash).
  * tableview_resolve_path (rel a dirname(ops_db) o absoluto).
- AppState::table_node_counts cache, refrescado tras load_input y mutaciones.
- views_table_overlay: rectangulo redondeado overlay ("Table  N") encima
  de cada nodo type_ref='Table'. Sigue camara via cam_x/cam_y/zoom.
- main.cpp:
  * --test-duckdb <path> smoke (SELECT 42).
  * --test-tableview <path> bulk test (1M rows count + page offset).
  * Refresh de counts tras load + reload_after_mutation.
  * Llamada a views_table_overlay despues de graph_labels_draw.
- CMakeLists.txt: link DuckDB::DuckDB + duckdb_copy_runtime.

Smoke tests:
- 1M rows count + page(offset=500k, limit=10) en 0.65 s end-to-end.
- Operations.db con un nodo Table apuntando a duckdb 1M filas: refresh
  reporta correctamente "1 tables, 1000000 total rows".
This commit is contained in:
Egutierrez
2026-05-01 01:24:25 +02:00
parent 20d8bbf360
commit 082008bc00
7 changed files with 597 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tableview.cpp
+357
View File
@@ -0,0 +1,357 @@
#include "tableview.h"
#include "duckdb.h"
#include "../../../../cpp/vendor/sqlite3/sqlite3.h"
#include <chrono>
#include <cstdio>
#include <cstring>
#include <cstdlib>
namespace ge {
namespace {
// Escape simple para SQL identifiers — solo permite [A-Za-z0-9_]. Usado para
// nombres de tabla / columnas que vienen de metadata. Si encuentra un char
// invalido, lo reemplaza por '_'. NO sustituye al binding de parametros.
std::string sanitize_ident(const char* s) {
std::string out;
if (!s) return out;
for (const char* p = s; *p; ++p) {
char c = *p;
if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')
|| (c >= '0' && c <= '9') || c == '_') out += c;
else out += '_';
}
return out;
}
// Escape para literales de string en SQL: dobla las comillas simples.
std::string sql_escape(const char* s) {
std::string out;
if (!s) return out;
for (const char* p = s; *p; ++p) {
out += *p;
if (*p == '\'') out += '\'';
}
return out;
}
// Helper RAII alrededor de duckdb_database/connection.
struct DuckHandle {
duckdb_database db = nullptr;
duckdb_connection cn = nullptr;
bool open(const char* path) {
if (duckdb_open(path, &db) == DuckDBError) return false;
if (duckdb_connect(db, &cn) == DuckDBError) return false;
return true;
}
~DuckHandle() {
if (cn) duckdb_disconnect(&cn);
if (db) duckdb_close(&db);
}
};
bool duck_query_silent(duckdb_connection cn, const char* sql) {
duckdb_result r;
duckdb_state st = duckdb_query(cn, sql, &r);
duckdb_destroy_result(&r);
return st == DuckDBSuccess;
}
} // namespace
bool tableview_smoke_test(const char* duckdb_path) {
DuckHandle h;
if (!h.open(duckdb_path)) return false;
duckdb_result r;
if (duckdb_query(h.cn, "SELECT 42 AS x", &r) == DuckDBError) {
duckdb_destroy_result(&r);
return false;
}
bool ok = duckdb_row_count(&r) == 1
&& duckdb_value_int64(&r, 0, 0) == 42;
duckdb_destroy_result(&r);
return ok;
}
bool tableview_count(const char* duckdb_path,
const char* duck_table,
const char* sql_filter,
int64_t* out)
{
if (!duckdb_path || !duck_table || !out) return false;
*out = 0;
DuckHandle h;
if (!h.open(duckdb_path)) return false;
std::string tname = sanitize_ident(duck_table);
if (tname.empty()) return false;
std::string sql = "SELECT COUNT(*) FROM " + tname;
if (sql_filter && *sql_filter) {
sql += " WHERE ";
sql += sql_filter;
}
duckdb_result r;
if (duckdb_query(h.cn, sql.c_str(), &r) == DuckDBError) {
std::fprintf(stderr, "[tableview_count] %s\n",
duckdb_result_error(&r) ? duckdb_result_error(&r) : "?");
duckdb_destroy_result(&r);
return false;
}
if (duckdb_row_count(&r) > 0) {
*out = duckdb_value_int64(&r, 0, 0);
}
duckdb_destroy_result(&r);
return true;
}
bool tableview_page(const char* duckdb_path,
const char* duck_table,
const char* id_column,
const std::vector<std::string>& columns,
const char* sql_filter,
const char* ops_db,
const char* row_type,
int64_t offset, int64_t limit,
std::vector<TablePageRow>* out)
{
if (!out) return false;
out->clear();
if (!duckdb_path || !duck_table || !id_column) return false;
if (limit < 1) limit = 1;
if (limit > 5000) limit = 5000;
DuckHandle h;
if (!h.open(duckdb_path)) return false;
std::string idc = sanitize_ident(id_column);
std::string tn = sanitize_ident(duck_table);
if (idc.empty() || tn.empty()) return false;
// Si tenemos ops_db y row_type, hacemos LEFT JOIN para detectar promovidas
// a traves de json_extract sobre entities.metadata.source.row_id.
bool join_ops = (ops_db && *ops_db && row_type && *row_type);
if (join_ops) {
// ATTACH del SQLite. Las attaches viven por conexion; idempotente
// detectando si ya existe seria mas robusto pero este path se llama
// por cada page() — abrimos conexion fresca cada vez asi que no.
std::string attach = "ATTACH '" + sql_escape(ops_db) + "' AS ops (TYPE SQLITE)";
if (!duck_query_silent(h.cn, attach.c_str())) {
// sin fallar — sin promovidas, solo perdemos el flag.
join_ops = false;
}
}
// SELECT: id_column + columns... + (CASE WHEN e.id NULL THEN '' ELSE e.id END).
std::string sel = "SELECT t." + idc;
for (const auto& c : columns) {
std::string cc = sanitize_ident(c.c_str());
if (!cc.empty()) sel += ", t." + cc;
}
if (join_ops) {
sel += ", COALESCE(e.id, '')";
} else {
sel += ", ''";
}
sel += " FROM " + tn + " AS t";
if (join_ops) {
sel += " LEFT JOIN ops.entities AS e ON ";
sel += "json_extract_string(e.metadata, '$.source.row_id') = CAST(t." + idc + " AS VARCHAR)";
sel += " AND e.type_ref = '" + sql_escape(row_type) + "'";
}
if (sql_filter && *sql_filter) {
sel += " WHERE ";
sel += sql_filter;
}
sel += " ORDER BY t." + idc + " ASC";
sel += " LIMIT " + std::to_string(limit);
sel += " OFFSET " + std::to_string(offset);
duckdb_result r;
if (duckdb_query(h.cn, sel.c_str(), &r) == DuckDBError) {
std::fprintf(stderr, "[tableview_page] %s\n",
duckdb_result_error(&r) ? duckdb_result_error(&r) : "?");
duckdb_destroy_result(&r);
return false;
}
idx_t rows = duckdb_row_count(&r);
idx_t cols = duckdb_column_count(&r);
out->reserve((size_t)rows);
for (idx_t row = 0; row < rows; ++row) {
TablePageRow tr;
// col 0 = id
if (!duckdb_value_is_null(&r, 0, row)) {
char* v = duckdb_value_varchar(&r, 0, row);
tr.id = v ? v : "";
if (v) duckdb_free(v);
}
// cols 1..N-2 = columns[]
idx_t expected_cols = (idx_t)columns.size();
tr.values.reserve(expected_cols);
for (idx_t i = 0; i < expected_cols; ++i) {
idx_t c = 1 + i;
if (c >= cols) { tr.values.emplace_back(""); continue; }
if (duckdb_value_is_null(&r, c, row)) {
tr.values.emplace_back("");
} else {
char* v = duckdb_value_varchar(&r, c, row);
tr.values.emplace_back(v ? v : "");
if (v) duckdb_free(v);
}
}
// ultima col = promoted_entity_id
idx_t prom_col = cols > 0 ? cols - 1 : 0;
if (cols > 0 && !duckdb_value_is_null(&r, prom_col, row)) {
char* v = duckdb_value_varchar(&r, prom_col, row);
tr.promoted_entity_id = v ? v : "";
if (v) duckdb_free(v);
}
out->push_back(std::move(tr));
}
duckdb_destroy_result(&r);
return true;
}
bool tableview_create(const char* ops_db,
const char* name,
const char* duckdb_path,
const char* duck_table,
const char* row_type,
char* out_id, std::size_t out_id_n)
{
if (!ops_db || !duckdb_path || !duck_table) return false;
if (!name || !*name) name = "Table";
auto now_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::system_clock::now().time_since_epoch()).count();
char id[80];
std::snprintf(id, sizeof(id), "table_%lld", (long long)now_ms);
if (out_id && out_id_n > 0) {
std::snprintf(out_id, out_id_n, "%s", id);
}
sqlite3* db = nullptr;
if (sqlite3_open_v2(ops_db, &db, SQLITE_OPEN_READWRITE, nullptr) != SQLITE_OK) {
if (db) sqlite3_close(db);
return false;
}
std::string meta = "{";
meta += "\"duckdb_path\":\""; meta += sql_escape(duckdb_path); meta += "\",";
meta += "\"table_name\":\""; meta += sql_escape(duck_table); meta += "\",";
meta += "\"row_type\":\""; meta += sql_escape(row_type ? row_type : ""); meta += "\",";
meta += "\"id_column\":\"id\",";
meta += "\"label_column\":\"name\",";
meta += "\"columns\":[],";
meta += "\"filter_sql\":\"\",";
meta += "\"expanded\":false";
meta += "}";
const char* ins =
"INSERT INTO entities(id, name, type_ref, status, tags, source, metadata, "
" created_at, updated_at) "
"VALUES (?, ?, 'Table', 'active', '[]', 'manual', ?, "
" strftime('%Y-%m-%dT%H:%M:%fZ','now'), "
" strftime('%Y-%m-%dT%H:%M:%fZ','now'))";
sqlite3_stmt* st = nullptr;
if (sqlite3_prepare_v2(db, ins, -1, &st, nullptr) != SQLITE_OK) {
sqlite3_close(db);
return false;
}
sqlite3_bind_text(st, 1, id, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(st, 2, name, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(st, 3, meta.c_str(), -1, SQLITE_TRANSIENT);
bool ok = sqlite3_step(st) == SQLITE_DONE;
sqlite3_finalize(st);
sqlite3_close(db);
return ok;
}
// ----------------------------------------------------------------------------
// Path resolution + counts cache
// ----------------------------------------------------------------------------
namespace {
uint64_t fnv1a64(const char* s) {
uint64_t h = 1469598103934665603ULL;
for (; s && *s; ++s) {
h ^= (uint8_t)*s;
h *= 1099511628211ULL;
}
return h;
}
std::string dirname_of(const char* path) {
if (!path) return "";
std::string s = path;
auto pos = s.find_last_of("/\\");
if (pos == std::string::npos) return ".";
return s.substr(0, pos);
}
bool is_absolute(const char* p) {
if (!p || !*p) return false;
if (p[0] == '/') return true;
if (std::strlen(p) >= 2 && p[1] == ':' &&
((p[0] >= 'A' && p[0] <= 'Z') || (p[0] >= 'a' && p[0] <= 'z'))) return true;
return false;
}
} // namespace
std::string tableview_resolve_path(const char* ops_db, const char* maybe_rel) {
if (!maybe_rel) return "";
if (is_absolute(maybe_rel)) return maybe_rel;
std::string base = dirname_of(ops_db);
if (base.empty()) base = ".";
return base + "/" + maybe_rel;
}
bool tableview_refresh_counts(const char* ops_db,
std::unordered_map<uint64_t, int64_t>* out)
{
if (!ops_db || !out) return false;
out->clear();
sqlite3* db = nullptr;
if (sqlite3_open_v2(ops_db, &db, SQLITE_OPEN_READONLY, nullptr) != SQLITE_OK) {
if (db) sqlite3_close(db);
return false;
}
const char* sql =
"SELECT id, "
" json_extract(metadata, '$.duckdb_path'), "
" json_extract(metadata, '$.table_name'), "
" json_extract(metadata, '$.filter_sql') "
"FROM entities WHERE type_ref = 'Table'";
sqlite3_stmt* st = nullptr;
if (sqlite3_prepare_v2(db, sql, -1, &st, nullptr) != SQLITE_OK) {
sqlite3_close(db);
return false;
}
while (sqlite3_step(st) == SQLITE_ROW) {
const unsigned char* id_p = sqlite3_column_text(st, 0);
const unsigned char* path_p = sqlite3_column_text(st, 1);
const unsigned char* tab_p = sqlite3_column_text(st, 2);
const unsigned char* flt_p = sqlite3_column_text(st, 3);
if (!id_p || !path_p || !tab_p) continue;
std::string abs = tableview_resolve_path(ops_db, (const char*)path_p);
int64_t total = 0;
if (!tableview_count(abs.c_str(), (const char*)tab_p,
flt_p ? (const char*)flt_p : nullptr,
&total)) {
std::fprintf(stderr,
"[tableview_refresh_counts] count failed for id=%s\n", id_p);
continue;
}
out->emplace(fnv1a64((const char*)id_p), total);
}
sqlite3_finalize(st);
sqlite3_close(db);
return true;
}
} // namespace ge