orm.c

Go to the documentation of this file.

 
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <cwist/core/orm/orm.h>
#include <cwist/core/mem/alloc.h>
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
#include <stdint.h>
#include <arpa/inet.h>
 
/* ------------------------------------------------------------------------- */
/* Internal ORM handle                                                       */
/* ------------------------------------------------------------------------- */
 
struct cwist_orm {
    int sock_fd;          
    bool auto_commit;      
    cwist_orm_dialect_t dialect; 
};
 
static volatile bool g_immediate_commit = false;
 
/* ------------------------------------------------------------------------- */
/* Framing helpers                                                           */
/* ------------------------------------------------------------------------- */
 
static int orm_recv_all(int fd, void *buf, size_t n) {
    size_t total = 0;
    char *p = (char *)buf;
    while (total < n) {
        ssize_t r = recv(fd, p + total, n - total, MSG_WAITALL);
        if (r <= 0) return -1;
        total += (size_t)r;
    }
    return 0;
}
 
static int orm_send_all(int fd, const void *buf, size_t n) {
    size_t total = 0;
    const char *p = (const char *)buf;
    while (total < n) {
        ssize_t w = send(fd, p + total, n - total, 0);
        if (w <= 0) return -1;
        total += (size_t)w;
    }
    return 0;
}
 
static int orm_exchange(cwist_orm_t *orm, const char *sql, char **out_payload) {
    *out_payload = NULL;
    if (!orm || orm->sock_fd < 0 || !sql) return -1;
 
    size_t sql_len = strlen(sql);
    if (sql_len > UINT32_MAX - 1) return -1;
 
    uint32_t net_len = htonl((uint32_t)sql_len);
    if (orm_send_all(orm->sock_fd, &net_len, sizeof(net_len)) != 0) return -1;
    if (orm_send_all(orm->sock_fd, sql, sql_len) != 0) return -1;
 
    uint32_t net_payload = 0;
    if (orm_recv_all(orm->sock_fd, &net_payload, sizeof(net_payload)) != 0) return -1;
    uint32_t payload_len = ntohl(net_payload);
    if (payload_len > 64 * 1024 * 1024) return -1; /* sanity ceiling */
 
    char *payload = (char *)malloc(payload_len + 1);
    if (!payload) return -1;
    if (payload_len > 0 && orm_recv_all(orm->sock_fd, payload, payload_len) != 0) {
        free(payload);
        return -1;
    }
    payload[payload_len] = '\0';
    *out_payload = payload;
    return 0;
}
 
static int orm_parse_status(const char *payload) {
    if (!payload) return -1;
    cJSON *root = cJSON_Parse(payload);
    if (!root) return -1;
    cJSON *status = cJSON_GetObjectItemCaseSensitive(root, "status");
    int rc = (cJSON_IsNumber(status)) ? (int)status->valuedouble : -1;
    cJSON_Delete(root);
    return rc;
}
 
/* ------------------------------------------------------------------------- */
/* Lifecycle                                                                 */
/* ------------------------------------------------------------------------- */
 
cwist_orm_t *cwist_orm_open_socket(int socket_fd) {
    if (socket_fd < 0) return NULL;
    cwist_orm_t *orm = (cwist_orm_t *)calloc(1, sizeof(*orm));
    if (!orm) return NULL;
    orm->sock_fd = socket_fd;
    orm->auto_commit = g_immediate_commit;
    orm->dialect = CWIST_ORM_SQLITE;
    return orm;
}
 
void cwist_orm_close_socket(cwist_orm_t *orm) {
    if (!orm) return;
    if (orm->sock_fd >= 0) {
        /* Best-effort rollback of any dangling transaction. */
        char *dummy = NULL;
        (void)orm_exchange(orm, "ROLLBACK;", &dummy);
        free(dummy);
        close(orm->sock_fd);
    }
    free(orm);
}
 
/* ------------------------------------------------------------------------- */
/* Transaction control                                                       */
/* ------------------------------------------------------------------------- */
 
void cwist_orm_immediate_commit(bool enable) {
    g_immediate_commit = enable;
}
 
void cwist_orm_use_dialect(cwist_orm_t *orm, cwist_orm_dialect_t dialect) {
    if (orm) orm->dialect = dialect;
}
 
cwist_error_t cwist_orm_commit(cwist_orm_t *orm) {
    return cwist_orm_exec(orm, "COMMIT;");
}
 
cwist_error_t cwist_orm_rollback(cwist_orm_t *orm) {
    return cwist_orm_exec(orm, "ROLLBACK;");
}
 
/* ------------------------------------------------------------------------- */
/* Low-level SQL                                                             */
/* ------------------------------------------------------------------------- */
 
cwist_error_t cwist_orm_exec(cwist_orm_t *orm, const char *sql) {
    cwist_error_t err = make_error(CWIST_ERR_INT16);
    if (!orm || !sql) {
        err.error.err_i16 = CWIST_ERROR_INVALID_PARAM;
        return err;
    }
 
    char *payload = NULL;
    if (orm_exchange(orm, sql, &payload) != 0) {
        err.error.err_i16 = CWIST_ERROR_IO;
        return err;
    }
 
    int status = orm_parse_status(payload);
    free(payload);
 
    if (status != 0) {
        err.error.err_i16 = CWIST_ERROR_PROTOCOL;
        return err;
    }
 
    /* Auto-commit write helpers if requested. */
    if (g_immediate_commit) {
        const char *upper = sql;
        while (*upper && *upper <= ' ') upper++;
        if ((strncasecmp(upper, "INSERT", 6) == 0) || (strncasecmp(upper, "UPDATE", 6) == 0) ||
            (strncasecmp(upper, "DELETE", 6) == 0)) {
            char *commit_payload = NULL;
            (void)orm_exchange(orm, "COMMIT;", &commit_payload);
            free(commit_payload);
        }
    }
 
    err.error.err_i16 = CWIST_SUCCESS;
    return err;
}
 
cwist_error_t cwist_orm_query(cwist_orm_t *orm, const char *sql, cJSON **result) {
    cwist_error_t err = make_error(CWIST_ERR_INT16);
    if (result) *result = NULL;
    if (!orm || !sql || !result) {
        err.error.err_i16 = CWIST_ERROR_INVALID_PARAM;
        return err;
    }
 
    char *payload = NULL;
    if (orm_exchange(orm, sql, &payload) != 0) {
        err.error.err_i16 = CWIST_ERROR_IO;
        return err;
    }
 
    cJSON *root = cJSON_Parse(payload);
    free(payload);
    if (!root) {
        err.error.err_i16 = CWIST_ERROR_PROTOCOL;
        return err;
    }
 
    cJSON *status = cJSON_GetObjectItemCaseSensitive(root, "status");
    if (!cJSON_IsNumber(status) || (int)status->valuedouble != 0) {
        cJSON_Delete(root);
        err.error.err_i16 = CWIST_ERROR_PROTOCOL;
        return err;
    }
 
    cJSON *rows = cJSON_DetachItemFromObjectCaseSensitive(root, "rows");
    cJSON_Delete(root);
    if (!rows) {
        /* Guarantee an array even on empty result. */
        rows = cJSON_CreateArray();
    }
 
    *result = rows;
    err.error.err_i16 = CWIST_SUCCESS;
    return err;
}
 
/* ------------------------------------------------------------------------- */
/* SQL value formatter                                                       */
/* ------------------------------------------------------------------------- */
 
static char *cwist_orm_escape_sqlite(const char *src) {
    if (!src) return NULL;
    size_t len = strlen(src);
    size_t extra = 0;
    for (size_t i = 0; i < len; i++) {
        if (src[i] == '\'') extra++;
    }
    char *dst = (char *)malloc(len + extra + 1);
    if (!dst) return NULL;
    size_t j = 0;
    for (size_t i = 0; i < len; i++) {
        if (src[i] == '\'') dst[j++] = '\'';
        dst[j++] = src[i];
    }
    dst[j] = '\0';
    return dst;
}
 
static char *cwist_orm_quote_identifier(const cwist_orm_t *orm, const char *id) {
    if (!orm || !id) return NULL;
    char quote_ch = '\0';
    char escape_ch = '\0';
    switch (orm->dialect) {
        case CWIST_ORM_POSTGRES:
            quote_ch = '"';
            escape_ch = '"';
            break;
        case CWIST_ORM_MYSQL:
        case CWIST_ORM_MARIADB:
        case CWIST_ORM_SQLITE:
            quote_ch = '`';
            escape_ch = '`';
            break;
        default: return strdup(id);
    }
 
    size_t len = strlen(id);
    size_t extra = 0;
    for (size_t i = 0; i < len; i++) {
        if (id[i] == quote_ch) extra++;
    }
    char *out = (char *)malloc(len + extra + 3);
    if (!out) return NULL;
    size_t j = 0;
    out[j++] = quote_ch;
    for (size_t i = 0; i < len; i++) {
        if (id[i] == quote_ch) out[j++] = escape_ch;
        out[j++] = id[i];
    }
    out[j++] = quote_ch;
    out[j] = '\0';
    return out;
}
 
static char *cwist_orm_json_to_sql_literal(const cwist_orm_t *orm, const cJSON *node) {
    if (!node) return strdup("NULL");
 
    if (cJSON_IsNull(node)) {
        return strdup("NULL");
    }
    if (cJSON_IsBool(node)) {
        if (orm && orm->dialect == CWIST_ORM_POSTGRES) {
            return strdup(cJSON_IsTrue(node) ? "TRUE" : "FALSE");
        }
        return strdup(cJSON_IsTrue(node) ? "1" : "0");
    }
    if (cJSON_IsNumber(node)) {
        char buf[64];
        snprintf(buf, sizeof(buf), "%g", node->valuedouble);
        return strdup(buf);
    }
    if (cJSON_IsString(node)) {
        if (!node->valuestring) return strdup("''");
        char *escaped = cwist_orm_escape_sqlite(node->valuestring);
        if (!escaped) return NULL;
        size_t elen = strlen(escaped);
        char *quoted = (char *)malloc(elen + 3);
        if (!quoted) {
            free(escaped);
            return NULL;
        }
        quoted[0] = '\'';
        memcpy(quoted + 1, escaped, elen);
        quoted[elen + 1] = '\'';
        quoted[elen + 2] = '\0';
        free(escaped);
        return quoted;
    }
 
    /* Fallback: stringify arrays/objects as JSON text. */
    char *raw = cJSON_PrintUnformatted((cJSON *)node);
    if (!raw) return strdup("NULL");
    char *escaped = cwist_orm_escape_sqlite(raw);
    free(raw);
    if (!escaped) return NULL;
    size_t elen = strlen(escaped);
    char *quoted = (char *)malloc(elen + 3);
    if (!quoted) {
        free(escaped);
        return NULL;
    }
    quoted[0] = '\'';
    memcpy(quoted + 1, escaped, elen);
    quoted[elen + 1] = '\'';
    quoted[elen + 2] = '\0';
    free(escaped);
    return quoted;
}
 
/* ------------------------------------------------------------------------- */
/* High-level helpers                                                        */
/* ------------------------------------------------------------------------- */
 
static char *orm_build_insert_sql(const cwist_orm_t *orm, const char *table, const cJSON *data) {
    if (!table || !data || !cJSON_IsObject(data)) return NULL;
 
    int col_count = 0;
    cJSON *item = NULL;
    cJSON_ArrayForEach(item, (cJSON *)data) col_count++;
    if (col_count == 0) return NULL;
 
    char *columns = (char *)malloc(1);
    char *values = (char *)malloc(1);
    if (!columns || !values) {
        free(columns);
        free(values);
        return NULL;
    }
    columns[0] = '\0';
    values[0] = '\0';
 
    char *qtable = cwist_orm_quote_identifier(orm, table);
    if (!qtable) {
        free(columns);
        free(values);
        return NULL;
    }
 
    int idx = 0;
    cJSON_ArrayForEach(item, (cJSON *)data) {
        char *literal = cwist_orm_json_to_sql_literal(orm, item);
        char *qid = cwist_orm_quote_identifier(orm, item->string);
        if (!literal || !qid) {
            free(literal);
            free(qid);
            free(qtable);
            free(columns);
            free(values);
            return NULL;
        }
 
        size_t need_col = strlen(columns) + strlen(qid) + 2;
        char *new_col = (char *)realloc(columns, need_col);
        if (!new_col) {
            free(literal);
            free(qid);
            free(qtable);
            free(columns);
            free(values);
            return NULL;
        }
        columns = new_col;
 
        size_t need_val = strlen(values) + strlen(literal) + 2;
        char *new_val = (char *)realloc(values, need_val);
        if (!new_val) {
            free(literal);
            free(qid);
            free(qtable);
            free(columns);
            free(values);
            return NULL;
        }
        values = new_val;
 
        if (idx > 0) {
            strcat(columns, ",");
            strcat(values, ",");
        }
        strcat(columns, qid);
        strcat(values, literal);
        free(literal);
        free(qid);
        idx++;
    }
 
    size_t sql_len = strlen(qtable) + strlen(columns) + strlen(values) + 32;
    char *sql = (char *)malloc(sql_len);
    if (!sql) {
        free(qtable);
        free(columns);
        free(values);
        return NULL;
    }
    snprintf(sql, sql_len, "INSERT INTO %s (%s) VALUES (%s)", qtable, columns, values);
    free(qtable);
    free(columns);
    free(values);
    return sql;
}
 
cwist_error_t cwist_orm_insert(cwist_orm_t *orm, const char *table, const cJSON *data) {
    cwist_error_t err = make_error(CWIST_ERR_INT16);
    if (!orm || !table || !data || !cJSON_IsObject(data)) {
        err.error.err_i16 = CWIST_ERROR_INVALID_PARAM;
        return err;
    }
 
    char *sql = orm_build_insert_sql(orm, table, data);
    if (!sql) {
        err.error.err_i16 = CWIST_ERROR_NOMEM;
        return err;
    }
 
    size_t len = strlen(sql);
    char *final = (char *)realloc(sql, len + 2);
    if (!final) {
        free(sql);
        err.error.err_i16 = CWIST_ERROR_NOMEM;
        return err;
    }
    final[len] = ';';
    final[len + 1] = '\0';
 
    err = cwist_orm_exec(orm, final);
    free(final);
    return err;
}
 
cwist_error_t cwist_orm_update(cwist_orm_t *orm, const char *table, const cJSON *data,
                               const char *where_clause) {
    cwist_error_t err = make_error(CWIST_ERR_INT16);
    if (!orm || !table || !data || !cJSON_IsObject(data)) {
        err.error.err_i16 = CWIST_ERROR_INVALID_PARAM;
        return err;
    }
 
    char *set_clause = (char *)malloc(1);
    if (!set_clause) {
        err.error.err_i16 = CWIST_ERROR_NOMEM;
        return err;
    }
    set_clause[0] = '\0';
 
    char *qtable = cwist_orm_quote_identifier(orm, table);
    if (!qtable) {
        free(set_clause);
        err.error.err_i16 = CWIST_ERROR_NOMEM;
        return err;
    }
 
    int idx = 0;
    cJSON *item = NULL;
    cJSON_ArrayForEach(item, (cJSON *)data) {
        char *literal = cwist_orm_json_to_sql_literal(orm, item);
        char *qid = cwist_orm_quote_identifier(orm, item->string);
        if (!literal || !qid) {
            free(literal);
            free(qid);
            free(qtable);
            free(set_clause);
            err.error.err_i16 = CWIST_ERROR_NOMEM;
            return err;
        }
        size_t need = strlen(set_clause) + strlen(qid) + strlen(literal) + 4;
        char *new_set = (char *)realloc(set_clause, need);
        if (!new_set) {
            free(literal);
            free(qid);
            free(qtable);
            free(set_clause);
            err.error.err_i16 = CWIST_ERROR_NOMEM;
            return err;
        }
        set_clause = new_set;
        if (idx > 0) strcat(set_clause, ",");
        strcat(set_clause, qid);
        strcat(set_clause, "=");
        strcat(set_clause, literal);
        free(literal);
        free(qid);
        idx++;
    }
 
    if (idx == 0) {
        free(qtable);
        free(set_clause);
        err.error.err_i16 = CWIST_ERROR_INVALID_PARAM;
        return err;
    }
 
    size_t sql_len =
        strlen(qtable) + strlen(set_clause) + 32 + (where_clause ? strlen(where_clause) : 0);
    char *sql = (char *)malloc(sql_len);
    if (!sql) {
        free(qtable);
        free(set_clause);
        err.error.err_i16 = CWIST_ERROR_NOMEM;
        return err;
    }
 
    if (where_clause && *where_clause) {
        snprintf(sql, sql_len, "UPDATE %s SET %s WHERE %s;", qtable, set_clause, where_clause);
    } else {
        snprintf(sql, sql_len, "UPDATE %s SET %s;", qtable, set_clause);
    }
    free(qtable);
    free(set_clause);
 
    err = cwist_orm_exec(orm, sql);
    free(sql);
    return err;
}
 
cwist_error_t cwist_orm_delete(cwist_orm_t *orm, const char *table, const char *where_clause) {
    cwist_error_t err = make_error(CWIST_ERR_INT16);
    if (!orm || !table) {
        err.error.err_i16 = CWIST_ERROR_INVALID_PARAM;
        return err;
    }
 
    char *qtable = cwist_orm_quote_identifier(orm, table);
    if (!qtable) {
        err.error.err_i16 = CWIST_ERROR_NOMEM;
        return err;
    }
 
    size_t sql_len = strlen(qtable) + 32 + (where_clause ? strlen(where_clause) : 0);
    char *sql = (char *)malloc(sql_len);
    if (!sql) {
        free(qtable);
        err.error.err_i16 = CWIST_ERROR_NOMEM;
        return err;
    }
 
    if (where_clause && *where_clause) {
        snprintf(sql, sql_len, "DELETE FROM %s WHERE %s;", qtable, where_clause);
    } else {
        snprintf(sql, sql_len, "DELETE FROM %s;", qtable);
    }
    free(qtable);
 
    err = cwist_orm_exec(orm, sql);
    free(sql);
    return err;
}
 
cwist_error_t cwist_orm_select(cwist_orm_t *orm, const char *table, const char *columns,
                               const char *where_clause, cJSON **result) {
    cwist_error_t err = make_error(CWIST_ERR_INT16);
    *result = NULL;
    if (!orm || !table || !columns) {
        err.error.err_i16 = CWIST_ERROR_INVALID_PARAM;
        return err;
    }
 
    char *qtable = cwist_orm_quote_identifier(orm, table);
    if (!qtable) {
        err.error.err_i16 = CWIST_ERROR_NOMEM;
        return err;
    }
 
    size_t sql_len =
        strlen(columns) + strlen(qtable) + 32 + (where_clause ? strlen(where_clause) : 0);
    char *sql = (char *)malloc(sql_len);
    if (!sql) {
        free(qtable);
        err.error.err_i16 = CWIST_ERROR_NOMEM;
        return err;
    }
 
    if (where_clause && *where_clause) {
        snprintf(sql, sql_len, "SELECT %s FROM %s WHERE %s;", columns, qtable, where_clause);
    } else {
        snprintf(sql, sql_len, "SELECT %s FROM %s;", columns, qtable);
    }
    free(qtable);
 
    err = cwist_orm_query(orm, sql, result);
    free(sql);
    return err;
}
 
/* ------------------------------------------------------------------ */
/* _Generic helpers: RETURNING INSERT                                */
/* ------------------------------------------------------------------ */
 
static char *orm_build_returning_sql(const cwist_orm_t *orm, const char *table, const cJSON *data,
                                     const char *returning_col) {
    char *base = orm_build_insert_sql(orm, table, data);
    if (!base) return NULL;
 
    char *qret = cwist_orm_quote_identifier(orm, returning_col);
    if (!qret) {
        free(base);
        return NULL;
    }
 
    const char *fmt;
    switch (orm->dialect) {
        case CWIST_ORM_POSTGRES:
        case CWIST_ORM_MARIADB: fmt = "%s RETURNING %s;"; break;
        case CWIST_ORM_MYSQL: fmt = "%s; SELECT LAST_INSERT_ID() AS %s;"; break;
        case CWIST_ORM_SQLITE:
        default: fmt = "%s; SELECT last_insert_rowid() AS %s;"; break;
    }
    /* Size from the format itself: a fixed +16 truncated the SQLite and
     * MySQL suffixes, so the INSERT ran but the SELECT never did. Raw
     * malloc like every SQL buffer in this file (the caller frees it). */
    int need = snprintf(NULL, 0, fmt, base, qret);
    char *sql = need >= 0 ? (char *)malloc((size_t)need + 1) : NULL;
    if (!sql) {
        free(base);
        free(qret);
        return NULL;
    }
    snprintf(sql, (size_t)need + 1, fmt, base, qret);
    free(base);
    free(qret);
    return sql;
}
 
cwist_error_t cwist_orm_insert_returning_json(cwist_orm_t *orm, const char *table,
                                              const cJSON *data, const char *returning_col,
                                              cJSON **out) {
    cwist_error_t err = make_error(CWIST_ERR_INT16);
    if (out) *out = NULL;
    if (!orm || !table || !data || !returning_col || !out) {
        err.error.err_i16 = CWIST_ERROR_INVALID_PARAM;
        return err;
    }
 
    char *sql = orm_build_returning_sql(orm, table, data, returning_col);
    if (!sql) {
        err.error.err_i16 = CWIST_ERROR_NOMEM;
        return err;
    }
 
    cJSON *rows = NULL;
    err = cwist_orm_query(orm, sql, &rows);
    free(sql);
    if (err.error.err_i16 != 0) {
        if (rows) cJSON_Delete(rows);
        return err;
    }
 
    cJSON *first = cJSON_GetArrayItem(rows, 0);
    if (!first) {
        cJSON_Delete(rows);
        err.error.err_i16 = CWIST_ERROR_PROTOCOL;
        return err;
    }
 
    cJSON *val = cJSON_GetObjectItemCaseSensitive(first, returning_col);
    if (!val) {
        cJSON_Delete(rows);
        err.error.err_i16 = CWIST_ERROR_PROTOCOL;
        return err;
    }
 
    *out = cJSON_Duplicate(val, 1);
    cJSON_Delete(rows);
    if (!*out) {
        err.error.err_i16 = CWIST_ERROR_NOMEM;
        return err;
    }
    err.error.err_i16 = 0;
    return err;
}
 
cwist_error_t cwist_orm_insert_returning_int(cwist_orm_t *orm, const char *table, const cJSON *data,
                                             const char *returning_col, int *out) {
    cJSON *val = NULL;
    cwist_error_t err = cwist_orm_insert_returning_json(orm, table, data, returning_col, &val);
    if (err.error.err_i16 != 0) return err;
    if (cJSON_IsNumber(val)) {
        *out = (int)val->valuedouble;
    } else {
        err.error.err_i16 = CWIST_ERROR_PROTOCOL;
    }
    cJSON_Delete(val);
    return err;
}
 
cwist_error_t cwist_orm_insert_returning_long(cwist_orm_t *orm, const char *table,
                                              const cJSON *data, const char *returning_col,
                                              long *out) {
    cJSON *val = NULL;
    cwist_error_t err = cwist_orm_insert_returning_json(orm, table, data, returning_col, &val);
    if (err.error.err_i16 != 0) return err;
    if (cJSON_IsNumber(val)) {
        *out = (long)val->valuedouble;
    } else {
        err.error.err_i16 = CWIST_ERROR_PROTOCOL;
    }
    cJSON_Delete(val);
    return err;
}
 
cwist_error_t cwist_orm_insert_returning_llong(cwist_orm_t *orm, const char *table,
                                               const cJSON *data, const char *returning_col,
                                               long long *out) {
    cJSON *val = NULL;
    cwist_error_t err = cwist_orm_insert_returning_json(orm, table, data, returning_col, &val);
    if (err.error.err_i16 != 0) return err;
    if (cJSON_IsNumber(val)) {
        *out = (long long)val->valuedouble;
    } else {
        err.error.err_i16 = CWIST_ERROR_PROTOCOL;
    }
    cJSON_Delete(val);
    return err;
}
 
/* ------------------------------------------------------------------ */
/* _Generic helpers: SELECT single scalar                            */
/* ------------------------------------------------------------------ */
 
static char *orm_build_select_one_sql(const cwist_orm_t *orm, const char *table,
                                      const char *column, const char *where_clause) {
    char *qtable = cwist_orm_quote_identifier(orm, table);
    char *qcol = cwist_orm_quote_identifier(orm, column);
    if (!qtable || !qcol) {
        free(qtable);
        free(qcol);
        return NULL;
    }
 
    size_t sql_len = strlen(qcol) + strlen(qtable) + 48 + (where_clause ? strlen(where_clause) : 0);
    char *sql = (char *)malloc(sql_len);
    if (!sql) {
        free(qtable);
        free(qcol);
        return NULL;
    }
 
    if (where_clause && *where_clause) {
        snprintf(sql, sql_len, "SELECT %s FROM %s WHERE %s LIMIT 1;", qcol, qtable, where_clause);
    } else {
        snprintf(sql, sql_len, "SELECT %s FROM %s LIMIT 1;", qcol, qtable);
    }
    free(qtable);
    free(qcol);
    return sql;
}
 
cwist_error_t cwist_orm_select_one_json(cwist_orm_t *orm, const char *table, const char *column,
                                        const char *where_clause, cJSON **out) {
    cwist_error_t err = make_error(CWIST_ERR_INT16);
    if (out) *out = NULL;
    if (!orm || !table || !column || !out) {
        err.error.err_i16 = CWIST_ERROR_INVALID_PARAM;
        return err;
    }
 
    char *sql = orm_build_select_one_sql(orm, table, column, where_clause);
    if (!sql) {
        err.error.err_i16 = CWIST_ERROR_NOMEM;
        return err;
    }
 
    cJSON *rows = NULL;
    err = cwist_orm_query(orm, sql, &rows);
    free(sql);
    if (err.error.err_i16 != 0) {
        if (rows) cJSON_Delete(rows);
        return err;
    }
 
    cJSON *first = cJSON_GetArrayItem(rows, 0);
    if (!first) {
        cJSON_Delete(rows);
        err.error.err_i16 = CWIST_ERROR_PROTOCOL;
        return err;
    }
 
    cJSON *val = cJSON_GetObjectItemCaseSensitive(first, column);
    if (!val) {
        cJSON_Delete(rows);
        err.error.err_i16 = CWIST_ERROR_PROTOCOL;
        return err;
    }
 
    *out = cJSON_Duplicate(val, 1);
    cJSON_Delete(rows);
    if (!*out) {
        err.error.err_i16 = CWIST_ERROR_NOMEM;
        return err;
    }
    err.error.err_i16 = 0;
    return err;
}
 
cwist_error_t cwist_orm_select_one_int(cwist_orm_t *orm, const char *table, const char *column,
                                       const char *where_clause, int *out) {
    cJSON *val = NULL;
    cwist_error_t err = cwist_orm_select_one_json(orm, table, column, where_clause, &val);
    if (err.error.err_i16 != 0) return err;
    if (cJSON_IsNumber(val)) {
        *out = (int)val->valuedouble;
    } else {
        err.error.err_i16 = CWIST_ERROR_PROTOCOL;
    }
    cJSON_Delete(val);
    return err;
}
 
cwist_error_t cwist_orm_select_one_long(cwist_orm_t *orm, const char *table, const char *column,
                                        const char *where_clause, long *out) {
    cJSON *val = NULL;
    cwist_error_t err = cwist_orm_select_one_json(orm, table, column, where_clause, &val);
    if (err.error.err_i16 != 0) return err;
    if (cJSON_IsNumber(val)) {
        *out = (long)val->valuedouble;
    } else {
        err.error.err_i16 = CWIST_ERROR_PROTOCOL;
    }
    cJSON_Delete(val);
    return err;
}
 
cwist_error_t cwist_orm_select_one_llong(cwist_orm_t *orm, const char *table, const char *column,
                                         const char *where_clause, long long *out) {
    cJSON *val = NULL;
    cwist_error_t err = cwist_orm_select_one_json(orm, table, column, where_clause, &val);
    if (err.error.err_i16 != 0) return err;
    if (cJSON_IsNumber(val)) {
        *out = (long long)val->valuedouble;
    } else {
        err.error.err_i16 = CWIST_ERROR_PROTOCOL;
    }
    cJSON_Delete(val);
    return err;
}
 
cwist_error_t cwist_orm_select_one_double(cwist_orm_t *orm, const char *table, const char *column,
                                          const char *where_clause, double *out) {
    cJSON *val = NULL;
    cwist_error_t err = cwist_orm_select_one_json(orm, table, column, where_clause, &val);
    if (err.error.err_i16 != 0) return err;
    if (cJSON_IsNumber(val)) {
        *out = val->valuedouble;
    } else {
        err.error.err_i16 = CWIST_ERROR_PROTOCOL;
    }
    cJSON_Delete(val);
    return err;
}
 
cwist_error_t cwist_orm_select_one_string(cwist_orm_t *orm, const char *table, const char *column,
                                          const char *where_clause, char **out) {
    cJSON *val = NULL;
    cwist_error_t err = cwist_orm_select_one_json(orm, table, column, where_clause, &val);
    if (err.error.err_i16 != 0) return err;
    if (cJSON_IsString(val)) {
        *out = strdup(val->valuestring);
        if (!*out) err.error.err_i16 = CWIST_ERROR_NOMEM;
    } else {
        err.error.err_i16 = CWIST_ERROR_PROTOCOL;
    }
    cJSON_Delete(val);
    return err;
}
 
/* ------------------------------------------------------------------ */
/* Exact 64-bit integers (#354)                                        */
/* ------------------------------------------------------------------ */
 
/* The typed helpers above read values through cJSON numbers, which are
 * doubles. The worker sends canonical integers as raw JSON digits, so the
 * exact path takes them from the response text instead: cJSON validates the
 * response, then a small scanner finds the same cell in the raw text. */
 
static const char *orm_json_ws(const char *p) {
    while (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r') p++;
    return p;
}
 
static const char *orm_json_skip_string(const char *p) {
    for (p++; *p && *p != '"'; p++) {
        if (*p == '\\' && !*++p) return NULL;
    }
    return *p == '"' ? p + 1 : NULL;
}
 
static const char *orm_json_skip_value(const char *p) {
    p = orm_json_ws(p);
    if (*p == '"') return orm_json_skip_string(p);
    if (*p == '{' || *p == '[') {
        int depth = 0;
        while (*p) {
            if (*p == '"') {
                p = orm_json_skip_string(p);
                if (!p) return NULL;
                continue;
            }
            if (*p == '{' || *p == '[') {
                depth++;
            } else if (*p == '}' || *p == ']') {
                if (--depth == 0) return p + 1;
            }
            p++;
        }
        return NULL;
    }
    const char *start = p;
    while (*p && *p != ',' && *p != '}' && *p != ']' && *p != ' ' && *p != '\t' && *p != '\n' &&
           *p != '\r')
        p++;
    return p > start ? p : NULL;
}
 
static const char *orm_json_object_get(const char *p, const char *key) {
    size_t key_len = strlen(key);
    p = orm_json_ws(p);
    if (*p != '{') return NULL;
    p = orm_json_ws(p + 1);
    while (*p == '"') {
        const char *ks = p;
        const char *ke = orm_json_skip_string(p);
        if (!ke) return NULL;
        p = orm_json_ws(ke);
        if (*p != ':') return NULL;
        p = orm_json_ws(p + 1);
        size_t n = (size_t)(ke - ks - 2);
        if (n == key_len && !memchr(ks + 1, '\\', n) && memcmp(ks + 1, key, n) == 0) return p;
        p = orm_json_skip_value(p);
        if (!p) return NULL;
        p = orm_json_ws(p);
        if (*p != ',') return NULL;
        p = orm_json_ws(p + 1);
    }
    return NULL;
}
 
static bool orm_parse_exact_i64(const char *p, int64_t *out) {
    const char *s = p;
    const char *e;
    if (*p == '"') {
        e = orm_json_skip_string(p);
        if (!e) return false;
        s = p + 1;
        e--; /* closing quote */
    } else {
        e = orm_json_skip_value(p);
        if (!e) return false;
    }
    size_t n = (size_t)(e - s);
    size_t i = (n > 0 && s[0] == '-') ? 1 : 0;
    if (i >= n || n > 20) return false;
    if (s[i] == '0' && (n - i > 1 || i == 1)) return false;
    for (size_t k = i; k < n; k++) {
        if (s[k] < '0' || s[k] > '9') return false;
    }
    char buf[24];
    memcpy(buf, s, n);
    buf[n] = '\0';
    errno = 0;
    long long v = strtoll(buf, NULL, 10);
    if (errno == ERANGE) return false;
    *out = (int64_t)v;
    return true;
}
 
static cwist_error_t orm_query_first_i64(cwist_orm_t *orm, const char *sql, const char *key,
                                         int64_t *out) {
    cwist_error_t err = make_error(CWIST_ERR_INT16);
    char *payload = NULL;
    if (orm_exchange(orm, sql, &payload) != 0) {
        err.error.err_i16 = CWIST_ERROR_IO;
        return err;
    }
 
    /* cJSON checks the status and that the cell is a number or a string. */
    err.error.err_i16 = CWIST_ERROR_PROTOCOL;
    cJSON *root = cJSON_Parse(payload);
    cJSON *status = cJSON_GetObjectItemCaseSensitive(root, "status");
    cJSON *first = cJSON_GetArrayItem(cJSON_GetObjectItemCaseSensitive(root, "rows"), 0);
    cJSON *val = cJSON_GetObjectItemCaseSensitive(first, key);
    bool shape_ok = cJSON_IsNumber(status) && (int)status->valuedouble == 0 &&
                    (cJSON_IsNumber(val) || cJSON_IsString(val));
    cJSON_Delete(root);
 
    if (shape_ok) {
        const char *rows = orm_json_object_get(payload, "rows");
        const char *row = rows && *rows == '[' ? orm_json_ws(rows + 1) : NULL;
        const char *cell = row ? orm_json_object_get(row, key) : NULL;
        int64_t v;
        if (cell && orm_parse_exact_i64(cell, &v)) {
            *out = v;
            err.error.err_i16 = CWIST_SUCCESS;
        }
    }
    free(payload);
    return err;
}
 
cwist_error_t cwist_orm_select_one_i64(cwist_orm_t *orm, const char *table, const char *column,
                                       const char *where_clause, int64_t *out) {
    cwist_error_t err = make_error(CWIST_ERR_INT16);
    if (!orm || !table || !column || !out) {
        err.error.err_i16 = CWIST_ERROR_INVALID_PARAM;
        return err;
    }
    char *sql = orm_build_select_one_sql(orm, table, column, where_clause);
    if (!sql) {
        err.error.err_i16 = CWIST_ERROR_NOMEM;
        return err;
    }
    err = orm_query_first_i64(orm, sql, column, out);
    free(sql);
    return err;
}
 
cwist_error_t cwist_orm_insert_returning_i64(cwist_orm_t *orm, const char *table,
                                             const cJSON *data, const char *returning_col,
                                             int64_t *out) {
    cwist_error_t err = make_error(CWIST_ERR_INT16);
    if (!orm || !table || !data || !returning_col || !out) {
        err.error.err_i16 = CWIST_ERROR_INVALID_PARAM;
        return err;
    }
    char *sql = orm_build_returning_sql(orm, table, data, returning_col);
    if (!sql) {
        err.error.err_i16 = CWIST_ERROR_NOMEM;
        return err;
    }
    err = orm_query_first_i64(orm, sql, returning_col, out);
    free(sql);
    return err;
}
 
/* ------------------------------------------------------------------ */
/* Column-typed result sets (#354)                                     */
/* ------------------------------------------------------------------ */
 
static int orm_b64_value(unsigned char c) {
    if (c >= 'A' && c <= 'Z') return c - 'A';
    if (c >= 'a' && c <= 'z') return c - 'a' + 26;
    if (c >= '0' && c <= '9') return c - '0' + 52;
    if (c == '+') return 62;
    if (c == '/') return 63;
    return -1;
}
 
static unsigned char *orm_b64_decode(const char *in, size_t *out_len) {
    size_t n = strlen(in);
    if (n % 4 != 0) {
        *out_len = SIZE_MAX;
        return NULL;
    }
    size_t pad = 0;
    if (n > 0 && in[n - 1] == '=') pad++;
    if (n > 1 && in[n - 2] == '=') pad++;
    size_t cap = n / 4 * 3 - pad;
    unsigned char *out = (unsigned char *)malloc(cap ? cap : 1);
    if (!out) {
        *out_len = SIZE_MAX;
        return NULL;
    }
    size_t o = 0;
    for (size_t i = 0; i < n; i += 4) {
        int v[4];
        int chars = 3;
        for (int k = 0; k < 4; k++) {
            char c = in[i + k];
            if (c == '=') {
                if (i + 4 != n || k < 2 || (k == 2 && in[i + 3] != '=')) {
                    free(out);
                    *out_len = SIZE_MAX;
                    return NULL;
                }
                v[k] = 0;
                chars--;
            } else {
                v[k] = orm_b64_value((unsigned char)c);
                if (v[k] < 0) {
                    free(out);
                    *out_len = SIZE_MAX;
                    return NULL;
                }
            }
        }
        unsigned triple = ((unsigned)v[0] << 18) | ((unsigned)v[1] << 12) |
                          ((unsigned)v[2] << 6) | (unsigned)v[3];
        if (o < cap) out[o++] = (unsigned char)(triple >> 16);
        if (o < cap) out[o++] = (unsigned char)(triple >> 8);
        if (o < cap) out[o++] = (unsigned char)triple;
    }
    *out_len = cap;
    return out;
}
 
static int orm_fill_typed_cell(cwist_orm_value_t *v, const cJSON *cell) {
    const cJSON *tag = cJSON_GetObjectItemCaseSensitive(cell, "t");
    if (!cJSON_IsString(tag) || !tag->valuestring) return CWIST_ERROR_PROTOCOL;
    const char *t = tag->valuestring;
    const cJSON *payload = cJSON_GetObjectItemCaseSensitive(cell, "v");
 
    if (strcmp(t, "null") == 0) {
        v->type = CWIST_ORM_TYPE_NULL;
        return CWIST_SUCCESS;
    }
    if (strcmp(t, "int") == 0) {
        if (!cJSON_IsString(payload) || !payload->valuestring) return CWIST_ERROR_PROTOCOL;
        const char *s = payload->valuestring;
        if (!*s) return CWIST_ERROR_PROTOCOL;
        errno = 0;
        char *endptr = NULL;
        long long val = strtoll(s, &endptr, 10);
        if (errno == ERANGE || !endptr || *endptr != '\0') return CWIST_ERROR_PROTOCOL;
        v->type = CWIST_ORM_TYPE_INTEGER;
        v->i64 = (int64_t)val;
        return CWIST_SUCCESS;
    }
    if (strcmp(t, "real") == 0) {
        if (!cJSON_IsNumber(payload)) return CWIST_ERROR_PROTOCOL;
        v->type = CWIST_ORM_TYPE_REAL;
        v->real = payload->valuedouble;
        return CWIST_SUCCESS;
    }
    if (strcmp(t, "text") == 0) {
        if (!cJSON_IsString(payload) || !payload->valuestring) return CWIST_ERROR_PROTOCOL;
        v->type = CWIST_ORM_TYPE_TEXT;
        v->text = strdup(payload->valuestring);
        return v->text ? CWIST_SUCCESS : CWIST_ERROR_NOMEM;
    }
    if (strcmp(t, "blob") == 0) {
        if (!cJSON_IsString(payload) || !payload->valuestring) return CWIST_ERROR_PROTOCOL;
        size_t len = 0;
        unsigned char *bytes = orm_b64_decode(payload->valuestring, &len);
        if (len == SIZE_MAX) return CWIST_ERROR_PROTOCOL;
        v->type = CWIST_ORM_TYPE_BLOB;
        v->blob = len ? bytes : NULL;
        v->blob_len = len;
        if (!len) free(bytes);
        return CWIST_SUCCESS;
    }
    return CWIST_ERROR_PROTOCOL;
}
 
cwist_error_t cwist_orm_query_typed(cwist_orm_t *orm, const char *sql,
                                    cwist_orm_result_t **result) {
    cwist_error_t err = make_error(CWIST_ERR_INT16);
    if (result) *result = NULL;
    if (!orm || !sql || !result) {
        err.error.err_i16 = CWIST_ERROR_INVALID_PARAM;
        return err;
    }
 
    char *payload = NULL;
    if (orm_exchange(orm, sql, &payload) != 0) {
        err.error.err_i16 = CWIST_ERROR_IO;
        return err;
    }
 
    err.error.err_i16 = CWIST_ERROR_PROTOCOL;
    cJSON *root = cJSON_Parse(payload);
    free(payload);
    if (!root) return err;
 
    cwist_orm_result_t *res = NULL;
 
    cJSON *status = cJSON_GetObjectItemCaseSensitive(root, "status");
    if (!cJSON_IsNumber(status) || (int)status->valuedouble != 0) goto done;
 
    cJSON *typed = cJSON_GetObjectItemCaseSensitive(root, "typed");
    cJSON *columns = cJSON_GetObjectItemCaseSensitive(typed, "columns");
    cJSON *trows = cJSON_GetObjectItemCaseSensitive(typed, "rows");
    if (!cJSON_IsArray(columns) || !cJSON_IsArray(trows)) goto done;
 
    res = (cwist_orm_result_t *)calloc(1, sizeof(*res));
    if (!res) {
        err.error.err_i16 = CWIST_ERROR_NOMEM;
        goto done;
    }
 
    res->column_count = (size_t)cJSON_GetArraySize(columns);
    res->row_count = (size_t)cJSON_GetArraySize(trows);
 
    res->columns = (char **)calloc(res->column_count ? res->column_count : 1, sizeof(char *));
    if (!res->columns) {
        err.error.err_i16 = CWIST_ERROR_NOMEM;
        goto fail;
    }
    for (size_t i = 0; i < res->column_count; i++) {
        cJSON *name = cJSON_GetArrayItem(columns, (int)i);
        if (!cJSON_IsString(name) || !name->valuestring) goto fail;
        res->columns[i] = strdup(name->valuestring);
        if (!res->columns[i]) {
            err.error.err_i16 = CWIST_ERROR_NOMEM;
            goto fail;
        }
    }
 
    if (res->row_count > 0) {
        if (res->column_count == 0 ||
            res->row_count > SIZE_MAX / res->column_count / sizeof(cwist_orm_value_t))
            goto fail;
        res->cells = (cwist_orm_value_t *)calloc(
            res->row_count * res->column_count, sizeof(cwist_orm_value_t));
        if (!res->cells) {
            err.error.err_i16 = CWIST_ERROR_NOMEM;
            goto fail;
        }
    }
 
    size_t idx = 0;
    cJSON *trow = NULL;
    cJSON_ArrayForEach(trow, trows) {
        if (!cJSON_IsArray(trow) || (size_t)cJSON_GetArraySize(trow) != res->column_count)
            goto fail;
        for (size_t c = 0; c < res->column_count; c++, idx++) {
            int rc = orm_fill_typed_cell(&res->cells[idx], cJSON_GetArrayItem(trow, (int)c));
            if (rc != CWIST_SUCCESS) {
                err.error.err_i16 = rc;
                goto fail;
            }
        }
    }
 
    *result = res;
    err.error.err_i16 = CWIST_SUCCESS;
    goto done;
 
fail:
    cwist_orm_result_free(res);
done:
    cJSON_Delete(root);
    return err;
}
 
void cwist_orm_result_free(cwist_orm_result_t *result) {
    if (!result) return;
    if (result->cells) {
        size_t total = result->row_count * result->column_count;
        for (size_t i = 0; i < total; i++) {
            free(result->cells[i].text);
            free(result->cells[i].blob);
        }
    }
    if (result->columns) {
        for (size_t i = 0; i < result->column_count; i++) free(result->columns[i]);
    }
    free(result->columns);
    free(result->cells);
    free(result);
}
 
size_t cwist_orm_result_column_index(const cwist_orm_result_t *result, const char *column) {
    if (!result || !column) return result ? result->column_count : 0;
    for (size_t i = 0; i < result->column_count; i++) {
        if (result->columns[i] && strcmp(result->columns[i], column) == 0) return i;
    }
    return result->column_count;
}
 
const cwist_orm_value_t *cwist_orm_result_cell(const cwist_orm_result_t *result, size_t row,
                                               size_t column) {
    if (!result || !result->cells || row >= result->row_count || column >= result->column_count)
        return NULL;
    return &result->cells[row * result->column_count + column];
}