fresco 0.0.1

data/lib/fresco/runtime/postgres.c

@@ -0,0 +1,339 @@
+/*
+ * Fresco Postgres shim. Wraps libpq behind the same str/int FFI
+ * surface as lib/sqlite.c so the Ruby wrapper has a single shape
+ * regardless of which adapter is linked. The Spinel codegen (M3+)
+ * only has to know the wrapper's method names, not the underlying
+ * client library.
+ *
+ * Shape divergences from sqlite.c — same Ruby-side method names but
+ * the C semantics differ because libpq isn't a cursor library:
+ *
+ *   - libpq fetches a whole PGresult per query. We model "cursor" as
+ *     a slot holding {sql, accumulated bind params, PGresult, current
+ *     row index}. `fresco_pg_prepare` only stores the SQL + sets the
+ *     slot up; nothing actually hits Postgres until the first `step`.
+ *     `bind_str`/`bind_int` accumulate values into the slot's param
+ *     array. The first `step` executes PQexecParams with the
+ *     accumulated values and sets row = 0; subsequent steps advance
+ *     row until ntuples is reached.
+ *
+ *   - `fresco_pg_last_insert_rowid` runs `SELECT lastval()`. Only
+ *     valid when the most recent statement triggered a sequence
+ *     (SERIAL / IDENTITY column). For tables without a sequence
+ *     callers should use `INSERT ... RETURNING id` + `col_int(0)`.
+ *
+ *   - Connection strings, not file paths. `fresco_pg_open(url)` is
+ *     a thin wrapper over PQconnectdb. URL goes in, 1-indexed handle
+ *     comes out.
+ *
+ * Errors
+ * ------
+ * Most functions return 0 on success and -1 on error. Detailed
+ * errmsg surfacing isn't wired through (same reasoning as sqlite.c:
+ * Spinel's :str return lifetime would have to be threaded through
+ * another rotating buffer). Callers branch on `< 0`.
+ *
+ * Build dependency
+ * ----------------
+ * Requires libpq's headers (`libpq-fe.h`) and library (`-lpq`) at
+ * compile/link time. On macOS via Homebrew:
+ *
+ *     export CPATH=/opt/homebrew/opt/libpq/include
+ *     export LIBRARY_PATH=/opt/homebrew/opt/libpq/lib
+ *     ./bin/release
+ *
+ * On Linux: `apt-get install libpq-dev` puts headers and lib in
+ * cc's default search paths.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <libpq-fe.h>
+
+#define FRESCO_PG_MAX_HANDLES   16
+#define FRESCO_PG_MAX_STMTS     64
+#define FRESCO_PG_MAX_PARAMS    32
+#define FRESCO_PG_COL_BUFSIZE   65536
+#define FRESCO_PG_COL_BUF_SLOTS 16
+
+typedef struct {
+    PGconn   *conn;            /* which connection this cursor belongs to */
+    char     *sql;             /* malloc'd, owned by the slot */
+    char     *params[FRESCO_PG_MAX_PARAMS]; /* text-format binds, malloc'd */
+    int       n_params;        /* highest 1-indexed param bound so far */
+    PGresult *result;          /* NULL until first step fires PQexecParams */
+    int       row;             /* current row index; -1 before first step */
+    int       ntuples;         /* PQntuples(result) once executed */
+    int       nfields;         /* PQnfields(result) once executed */
+} fresco_pg_cursor;
+
+static PGconn           *fresco_pg_handles[FRESCO_PG_MAX_HANDLES] = {0};
+static fresco_pg_cursor *fresco_pg_stmts[FRESCO_PG_MAX_STMTS]     = {0};
+
+/* Rotating return buffers for col_str. Same rationale as sqlite.c:
+ * callers stash several col_str results into different variables /
+ * containers before the buffer would otherwise rotate, and a single
+ * static buf would alias them all to the last call. */
+static char fresco_pg_col_buf[FRESCO_PG_COL_BUF_SLOTS][FRESCO_PG_COL_BUFSIZE];
+static int  fresco_pg_col_slot = 0;
+
+static void fresco_pg_cursor_free_params(fresco_pg_cursor *c) {
+    int i;
+    for (i = 0; i < FRESCO_PG_MAX_PARAMS; i++) {
+        if (c->params[i]) {
+            free(c->params[i]);
+            c->params[i] = NULL;
+        }
+    }
+    c->n_params = 0;
+}
+
+static void fresco_pg_cursor_free(fresco_pg_cursor *c) {
+    if (!c) return;
+    if (c->result) {
+        PQclear(c->result);
+        c->result = NULL;
+    }
+    fresco_pg_cursor_free_params(c);
+    if (c->sql) {
+        free(c->sql);
+        c->sql = NULL;
+    }
+    free(c);
+}
+
+/* Open a connection. Returns a 1-indexed handle on success (0 reserved
+ * for "uninitialised"); -1 if the slot table is full or PQconnectdb
+ * fails. URL accepts any libpq-conninfo string: postgres://user@host/db
+ * or `host=... user=... dbname=...`. Closing frees the slot for re-use.
+ */
+int fresco_pg_open(const char *url) {
+    int i;
+    for (i = 0; i < FRESCO_PG_MAX_HANDLES; i++) {
+        if (fresco_pg_handles[i] == NULL) {
+            PGconn *conn = PQconnectdb(url);
+            if (PQstatus(conn) != CONNECTION_OK) {
+                PQfinish(conn);
+                return -1;
+            }
+            fresco_pg_handles[i] = conn;
+            return i + 1;
+        }
+    }
+    return -1;
+}
+
+int fresco_pg_close(int h) {
+    int i;
+    if (h < 1 || h > FRESCO_PG_MAX_HANDLES) return -1;
+    PGconn *conn = fresco_pg_handles[h - 1];
+    if (conn == NULL) return -1;
+    /* Free any cursors still attached so dangling slots don't outlive
+     * the connection. */
+    for (i = 0; i < FRESCO_PG_MAX_STMTS; i++) {
+        if (fresco_pg_stmts[i] != NULL && fresco_pg_stmts[i]->conn == conn) {
+            fresco_pg_cursor_free(fresco_pg_stmts[i]);
+            fresco_pg_stmts[i] = NULL;
+        }
+    }
+    PQfinish(conn);
+    fresco_pg_handles[h - 1] = NULL;
+    return 0;
+}
+
+/* No-bind statement runner. Equivalent to sqlite_exec — fires the SQL,
+ * discards the result, returns 0 on success and -1 on error. Use for
+ * DDL, BEGIN/COMMIT, and queries whose values are constants. For
+ * anything user-supplied always use prepare + bind + step + finalize. */
+int fresco_pg_exec(int h, const char *sql) {
+    if (h < 1 || h > FRESCO_PG_MAX_HANDLES) return -1;
+    PGconn *conn = fresco_pg_handles[h - 1];
+    if (conn == NULL) return -1;
+    PGresult *res = PQexec(conn, sql);
+    ExecStatusType s = PQresultStatus(res);
+    int ok = (s == PGRES_COMMAND_OK || s == PGRES_TUPLES_OK);
+    PQclear(res);
+    return ok ? 0 : -1;
+}
+
+/* Set up a cursor over a parameterised statement. Returns a 1-indexed
+ * cursor id (>= 1) on success, -1 on failure. The actual execution is
+ * deferred to the first `step` call so accumulated bind_str/bind_int
+ * values land in the PQexecParams call. Placeholder syntax is $1, $2,
+ * ... (libpq native); SQLite's `?` won't work. */
+int fresco_pg_prepare(int h, const char *sql) {
+    int i;
+    if (h < 1 || h > FRESCO_PG_MAX_HANDLES) return -1;
+    PGconn *conn = fresco_pg_handles[h - 1];
+    if (conn == NULL) return -1;
+    for (i = 0; i < FRESCO_PG_MAX_STMTS; i++) {
+        if (fresco_pg_stmts[i] == NULL) {
+            fresco_pg_cursor *c = calloc(1, sizeof(fresco_pg_cursor));
+            if (!c) return -1;
+            c->conn = conn;
+            c->sql  = strdup(sql);
+            if (!c->sql) {
+                free(c);
+                return -1;
+            }
+            c->row     = -1;
+            c->ntuples = 0;
+            c->nfields = 0;
+            fresco_pg_stmts[i] = c;
+            return i + 1;
+        }
+    }
+    return -1;
+}
+
+/* Stash a text param at 1-indexed position. Overwrites any prior bind
+ * at the same index. Strings are duplicated — caller's pointer doesn't
+ * need to outlive the bind. */
+int fresco_pg_bind_str(int cid, int idx, const char *value) {
+    if (cid < 1 || cid > FRESCO_PG_MAX_STMTS) return -1;
+    fresco_pg_cursor *c = fresco_pg_stmts[cid - 1];
+    if (c == NULL) return -1;
+    if (idx < 1 || idx > FRESCO_PG_MAX_PARAMS) return -1;
+    if (c->params[idx - 1]) {
+        free(c->params[idx - 1]);
+        c->params[idx - 1] = NULL;
+    }
+    char *copy = strdup(value);
+    if (!copy) return -1;
+    c->params[idx - 1] = copy;
+    if (idx > c->n_params) c->n_params = idx;
+    return 0;
+}
+
+/* Int binds are stringified into the param slot — libpq's text-format
+ * coercion casts them back to the column type. Fixed-size decimal buf
+ * (32 bytes) covers every int range comfortably. */
+int fresco_pg_bind_int(int cid, int idx, int value) {
+    if (cid < 1 || cid > FRESCO_PG_MAX_STMTS) return -1;
+    fresco_pg_cursor *c = fresco_pg_stmts[cid - 1];
+    if (c == NULL) return -1;
+    if (idx < 1 || idx > FRESCO_PG_MAX_PARAMS) return -1;
+    char buf[32];
+    snprintf(buf, sizeof(buf), "%d", value);
+    if (c->params[idx - 1]) {
+        free(c->params[idx - 1]);
+        c->params[idx - 1] = NULL;
+    }
+    char *copy = strdup(buf);
+    if (!copy) return -1;
+    c->params[idx - 1] = copy;
+    if (idx > c->n_params) c->n_params = idx;
+    return 0;
+}
+
+/* 1 -> row available, 0 -> done (no more rows), -1 -> error or invalid
+ * cursor. First call fires PQexecParams; subsequent calls advance the
+ * row index. Same iteration pattern as sqlite_step. */
+int fresco_pg_step(int cid) {
+    if (cid < 1 || cid > FRESCO_PG_MAX_STMTS) return -1;
+    fresco_pg_cursor *c = fresco_pg_stmts[cid - 1];
+    if (c == NULL) return -1;
+    if (c->result == NULL) {
+        /* First step: fire the query with accumulated binds. */
+        const char *param_values[FRESCO_PG_MAX_PARAMS];
+        int i;
+        for (i = 0; i < c->n_params; i++) {
+            /* libpq treats NULL as SQL NULL; we treat un-bound slots
+             * as empty strings to match sqlite's "bind silently makes
+             * the value visible" ergonomics. */
+            param_values[i] = c->params[i] ? c->params[i] : "";
+        }
+        c->result = PQexecParams(c->conn, c->sql, c->n_params,
+                                 NULL, param_values, NULL, NULL, 0);
+        ExecStatusType s = PQresultStatus(c->result);
+        if (s != PGRES_TUPLES_OK && s != PGRES_COMMAND_OK) {
+            PQclear(c->result);
+            c->result = NULL;
+            return -1;
+        }
+        c->ntuples = PQntuples(c->result);
+        c->nfields = PQnfields(c->result);
+        c->row     = -1;
+    }
+    c->row++;
+    return c->row < c->ntuples ? 1 : 0;
+}
+
+const char *fresco_pg_col_str(int cid, int idx) {
+    if (cid < 1 || cid > FRESCO_PG_MAX_STMTS) return "";
+    fresco_pg_cursor *c = fresco_pg_stmts[cid - 1];
+    if (c == NULL || c->result == NULL || c->row < 0 || c->row >= c->ntuples) return "";
+    if (PQgetisnull(c->result, c->row, idx)) return "";
+    const char *v = PQgetvalue(c->result, c->row, idx);
+    if (!v) return "";
+    size_t n = strlen(v);
+    if (n >= FRESCO_PG_COL_BUFSIZE) n = FRESCO_PG_COL_BUFSIZE - 1;
+    char *buf = fresco_pg_col_buf[fresco_pg_col_slot];
+    fresco_pg_col_slot = (fresco_pg_col_slot + 1) % FRESCO_PG_COL_BUF_SLOTS;
+    memcpy(buf, v, n);
+    buf[n] = '\0';
+    return buf;
+}
+
+int fresco_pg_col_int(int cid, int idx) {
+    if (cid < 1 || cid > FRESCO_PG_MAX_STMTS) return 0;
+    fresco_pg_cursor *c = fresco_pg_stmts[cid - 1];
+    if (c == NULL || c->result == NULL || c->row < 0 || c->row >= c->ntuples) return 0;
+    if (PQgetisnull(c->result, c->row, idx)) return 0;
+    const char *v = PQgetvalue(c->result, c->row, idx);
+    return v ? atoi(v) : 0;
+}
+
+int fresco_pg_col_count(int cid) {
+    if (cid < 1 || cid > FRESCO_PG_MAX_STMTS) return 0;
+    fresco_pg_cursor *c = fresco_pg_stmts[cid - 1];
+    if (c == NULL) return 0;
+    return c->nfields;
+}
+
+int fresco_pg_finalize(int cid) {
+    if (cid < 1 || cid > FRESCO_PG_MAX_STMTS) return 0;
+    fresco_pg_cursor *c = fresco_pg_stmts[cid - 1];
+    if (c == NULL) return 0;
+    fresco_pg_cursor_free(c);
+    fresco_pg_stmts[cid - 1] = NULL;
+    return 0;
+}
+
+/* Reset the cursor so it can be re-stepped (e.g. inside a loop where
+ * bound params change between iterations). Drops the prior PGresult
+ * but keeps bound params and the SQL string. The next step will
+ * re-execute. */
+int fresco_pg_reset(int cid) {
+    if (cid < 1 || cid > FRESCO_PG_MAX_STMTS) return -1;
+    fresco_pg_cursor *c = fresco_pg_stmts[cid - 1];
+    if (c == NULL) return -1;
+    if (c->result) {
+        PQclear(c->result);
+        c->result = NULL;
+    }
+    c->row     = -1;
+    c->ntuples = 0;
+    c->nfields = 0;
+    return 0;
+}
+
+/* Postgres doesn't have a per-connection "last rowid" — it has
+ * sequence currvals. `SELECT lastval()` returns the most recent value
+ * returned by any sequence in the current session. Only valid when the
+ * prior statement actually triggered a sequence; otherwise returns -1.
+ * For predictable behavior callers should hand-roll `INSERT ... RETURNING
+ * id` + `col_int(0)` instead. */
+int fresco_pg_last_insert_rowid(int h) {
+    if (h < 1 || h > FRESCO_PG_MAX_HANDLES) return -1;
+    PGconn *conn = fresco_pg_handles[h - 1];
+    if (conn == NULL) return -1;
+    PGresult *res = PQexec(conn, "SELECT lastval()");
+    if (PQresultStatus(res) != PGRES_TUPLES_OK || PQntuples(res) < 1) {
+        PQclear(res);
+        return -1;
+    }
+    int rowid = atoi(PQgetvalue(res, 0, 0));
+    PQclear(res);
+    return rowid;
+}