Biblioteca estándar

SQL, Mongo y Redis

Todas las bases abren con db_open y están gateadas por require db(scope). Tres familias: SQL (SQLite/Postgres/MySQL), documentos (MongoDB, mongo_), key-value (Redis, redis_). Todos los drivers son puro-Rust (un solo binario estático).

-- Doc example: SQL over SQLite in-memory (real, no server). Same API for Postgres/MySQL.
intent: "doc example: SQL"
require db(":memory:")

db_open(":memory:", "memory")
sql_exec("CREATE TABLE demo (n TEXT)")
sql_exec("INSERT INTO demo VALUES (?)", ["it works"])
print("sql demo → " + (sql("SELECT n FROM demo")[0])["n"])
db_close()

test "create, parameterized insert, query"
    db_open(":memory:", "memory")
    sql_exec("CREATE TABLE items (name TEXT, price REAL)")
    sql_exec("INSERT INTO items VALUES (?, ?)", ["Laptop", 999])
    sql_exec("INSERT INTO items VALUES (?, ?)", ["Mouse", 25])
    let rows be sql("SELECT name, price FROM items WHERE price > ? ORDER BY price DESC", [50])
    assert_eq(length(rows), 1)
    assert_eq(name of (rows[0]), "Laptop")
    db_close()

SQL (SQLite / Postgres / MySQL)§

require db("./store.db")
db_open("./store.db")                 -- archivo → SQLite. ":memory:" con modo "memory". postgres:// / mysql://
sql_exec("INSERT INTO users (name) VALUES (?)", ["Ada"])   -- parametrizado (seguro)
let rows be sql("SELECT * FROM users WHERE id = ?", [1])
give paged("SELECT * FROM users ORDER BY id")              -- paginación para un handler de ruta

Los placeholders son siempre ? (Postgres los reescribe a $n internamente; MySQL usa ? nativo). Las columnas bytes round-trippean a BLOB/BYTEA byte-exacto.

MongoDB (documentos)§

require db("mongodb://localhost/appdb")
db_open("mongodb://host:27017/appdb")
let id be mongo_insert("users", {"name": "Ana", "age": 30})
let adults be mongo_find("users", {"age": {"$gte": 18}}, {"sort": {"age": -1}})

Todos: mongo_find(coll, filtro?, opts?) (opts {limit, skip, sort: {f: 1/-1}, fields: {f: 1}}), mongo_find_one(coll, filtro?) → doc o nothing, mongo_insert(coll, doc) → _id, mongo_insert_many(coll, docs) → ids, mongo_update(coll, filtro, update) → {matched, modified} (update usa operadores, {"$set": …}), mongo_delete(coll, filtro) → {deleted}, mongo_count(coll, filtro?), mongo_aggregate(coll, pipeline), mongo_collections(). Documentos/filtros son mapas ↔ BSON; _id se lee como texto hex y un string de 24 hex bajo _id en un filtro se convierte a ObjectId.

Redis (key-value / cache / estructuras)§

require db("redis://localhost")
db_open("redis://localhost:6379")
redis_set("session:42", token, 3600)             -- con TTL
let v be redis_get("session:42")
redis_set("cfg", json_encode({"theme": "dark"})) -- la data estructurada es explícita

Los valores son byte-strings (text si es UTF-8, si no bytes; enteros → number); los argumentos aceptan text/bytes/number (cualquier otra cosa: json_encode). Todos:

• strings / claves: redis_get(key) → valor o nothing, redis_set(key, val, ttl_secs?), redis_del(key…), redis_exists(key…), redis_mget(keys), redis_mset(mapa), redis_keys(patrón) (O(N)), redis_type(key).
• contadores: redis_incr, redis_decr, redis_incrby(key, n) (atómicos).
• TTL: redis_expire(key, secs), redis_ttl(key) (-1 sin TTL, -2 ausente), redis_persist(key).
• hashes: redis_hget(key, campo), redis_hset(key, mapa) → campos nuevos, redis_hdel(key, campo…), redis_hgetall(key) → mapa, redis_hincrby(key, campo, n).
• listas: redis_lpush/redis_rpush(key, val…) → largo, redis_lpop/redis_rpop(key), redis_lrange(key, inicio, fin), redis_llen(key).
• sets: redis_sadd/redis_srem(key, miembro…), redis_smembers(key), redis_sismember(key, miembro).
• lock distribuido: redis_lock(key, ttl_ms?) → token o nothing si está tomado (SET NX PX, 30000 ms por defecto), redis_unlock(key, token) → bool (atómico, sólo libera quien tiene el token).

db_close(path?) cierra una conexión de cualquier familia.

Gotcha del db-index de Redis: redis://host:6379 → scope redis://host (sin /0); …/0 es un scope distinto.