egutierrez
082008bc00
- 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".
80 lines
3.6 KiB
C++
80 lines
3.6 KiB
C++
#pragma once
|
|
#include <cstdint>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
|
|
// Vista tabular respaldada por DuckDB (issue 0010). Cada nodo `Table` del
|
|
// grafo apunta via metadata a un archivo `.duckdb` y a una tabla dentro
|
|
// de el. Las filas viven en DuckDB; el grafo solo materializa las que
|
|
// se "promueven" a entidades (issue 0011).
|
|
//
|
|
// Convencion de paths: `metadata.duckdb_path` es relativo al directorio del
|
|
// proyecto (la raiz donde vive operations.db). El caller resuelve a path
|
|
// absoluto antes de pasar a estas funciones.
|
|
|
|
namespace ge {
|
|
|
|
struct TablePageRow {
|
|
std::string id; // valor del id_column en duckdb (key natural)
|
|
std::vector<std::string> values; // un valor por columna en `columns[]`
|
|
std::string promoted_entity_id; // "" si la fila no esta promovida; sino, ops.entities.id
|
|
};
|
|
|
|
// Crea o sobrescribe el nodo Table. Inserta una fila en operations.db con
|
|
// type_ref='Table' y metadata apuntando al duckdb_path/table_name. Genera
|
|
// un id propio. Devuelve false si SQLite falla o si los argumentos basicos
|
|
// estan vacios.
|
|
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);
|
|
|
|
// Cuenta las filas de duckdb_path/duck_table aplicando opcionalmente
|
|
// `sql_filter` (clausula WHERE sin la palabra WHERE — vacio = sin filtro).
|
|
// Devuelve false en error de IO/parse.
|
|
bool tableview_count(const char* duckdb_path,
|
|
const char* duck_table,
|
|
const char* sql_filter,
|
|
int64_t* out);
|
|
|
|
// Devuelve una pagina ordenada por `id_column` ASC. Cada fila incluye los
|
|
// valores de `columns` resueltos a string + el flag `promoted_entity_id`
|
|
// computado via LEFT JOIN contra ops.entities (DuckDB attach a SQLite).
|
|
// limit clampeado en [1,5000].
|
|
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, // para LEFT JOIN de promovidas
|
|
const char* row_type, // discriminante en ops.entities
|
|
int64_t offset, int64_t limit,
|
|
std::vector<TablePageRow>* out);
|
|
|
|
// Smoke test: abre el .duckdb, corre `SELECT 42 AS x` y verifica que
|
|
// devuelve la fila esperada. Devuelve true si todo OK.
|
|
bool tableview_smoke_test(const char* duckdb_path);
|
|
|
|
// Resuelve un path posiblemente relativo a la ubicacion de operations.db.
|
|
// Si es absoluto (empieza por '/' o '<letra>:' en Windows), se devuelve
|
|
// tal cual.
|
|
std::string tableview_resolve_path(const char* ops_db, const char* maybe_rel);
|
|
|
|
// Refresca el cache de conteos de filas por nodo Table. Lee
|
|
// type_ref='Table' de operations.db, extrae metadata.duckdb_path/table_name,
|
|
// llama a tableview_count y guarda el resultado indexado por
|
|
// fnv1a64(entity_id) — la misma key que usa graph_sources al setear
|
|
// node.user_data, asi que el render puede mirar directo por user_data.
|
|
// Si una tabla falla, su entrada NO se inserta y se imprime un warning.
|
|
struct TableCounts {
|
|
// user_data hash (fnv1a64 del entity id) -> total filas tras filter_sql.
|
|
// -1 indica error/ausencia.
|
|
};
|
|
bool tableview_refresh_counts(const char* ops_db,
|
|
std::unordered_map<uint64_t, int64_t>* out);
|
|
|
|
} // namespace ge
|