Home /Modules/db-connector/sldbc.c

sldbc.c

lib/db-connector/src/sldbc.c · 304 line(s) · c

/*
 * lib/db-connector/src/sldbc.c
 *
 * SLeeLa DB Connector implementation: a tiny driver manager plus the bundled
 * "sleelasql" driver wrapping lib/sleela-sql (ssql_*). External-RDBMS schemes
 * are registered by name but return SLDBC_UNSUPPORTED (honest stubs).
 */
/* open_memstream is POSIX.1-2008; request it before any libc header. */
#ifndef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200809L
#endif

#include "sldbc.h"
#include "../../sleela-sql/native/include/sleela_sql.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

const char *sldbc_version(void) { return "1.0.0"; }

/* ---- schemes --------------------------------------------------------- */
/* The one real driver, plus the external backends the connector knows the
 * NAME of but cannot yet reach (mirrors api/database's kinds). */
static const char *k_real_driver = "sleelasql";
static const char *k_stub_drivers[] = {
    "postgresql", "mysql", "mariadb", "sqlite", "sqlserver", "oracle", "odbc"};

int sldbc_driver_available(const char *scheme) {
  if (!scheme) return 0;
  return strcmp(scheme, k_real_driver) == 0 ? 1 : 0;
}

static int scheme_is_known(const char *scheme) {
  if (sldbc_driver_available(scheme)) return 1;
  for (size_t i = 0; i < sizeof k_stub_drivers / sizeof k_stub_drivers[0]; ++i)
    if (strcmp(scheme, k_stub_drivers[i]) == 0) return 1;
  return 0;
}

/* ---- handles --------------------------------------------------------- */
struct sldbc_conn {
  char scheme[32];
  ssql_db db; /* valid when scheme == sleelasql */
};

struct sldbc_stmt {
  sldbc_conn *conn;
  ssql_stmt *s; /* underlying ssql prepared statement */
};

struct sldbc_rows {
  char **cols;
  size_t ncols;
  char ***cells; /* cells[row][col] */
  size_t nrows;
};

/* ---- driver manager -------------------------------------------------- */
sldbc_status sldbc_open(const char *url, sldbc_conn **out) {
  if (!url || !out) return SLDBC_ERR_ARG;
  *out = NULL;
  const char *colon = strchr(url, ':');
  if (!colon || colon == url) return SLDBC_ERR_URL;
  size_t slen = (size_t)(colon - url);
  if (slen >= 32) return SLDBC_ERR_URL;
  char scheme[32];
  memcpy(scheme, url, slen);
  scheme[slen] = 0;
  const char *target = colon + 1;

  if (!scheme_is_known(scheme)) return SLDBC_ERR_NODRIVER;
  if (!sldbc_driver_available(scheme)) return SLDBC_UNSUPPORTED; /* stub backend */

  sldbc_conn *c = (sldbc_conn *)calloc(1, sizeof *c);
  if (!c) return SLDBC_ERR_OOM;
  snprintf(c->scheme, sizeof c->scheme, "%s", scheme);
  if (!*target) target = ".";
  if (ssql_open(&c->db, target) != SSQL_OK) {
    free(c);
    return SLDBC_ERR_OPEN;
  }
  *out = c;
  return SLDBC_OK;
}

void sldbc_close(sldbc_conn *c) { free(c); }

const char *sldbc_driver_name(const sldbc_conn *c) {
  return c ? c->scheme : "";
}

/* ---- statements ------------------------------------------------------ */
sldbc_status sldbc_prepare(sldbc_conn *c, const char *sql, sldbc_stmt **out) {
  if (!c || !sql || !out) return SLDBC_ERR_ARG;
  *out = NULL;
  sldbc_stmt *st = (sldbc_stmt *)calloc(1, sizeof *st);
  if (!st) return SLDBC_ERR_OOM;
  st->conn = c;
  if (ssql_prepare(&c->db, sql, SSQL_DIALECT_AUTO, &st->s) != SSQL_OK) {
    free(st);
    return SLDBC_ERR_EXEC;
  }
  *out = st;
  return SLDBC_OK;
}

sldbc_status sldbc_bind(sldbc_stmt *s, int index, const char *value) {
  if (!s || !s->s) return SLDBC_ERR_ARG;
  return ssql_bind(s->s, index, value) == SSQL_OK ? SLDBC_OK : SLDBC_ERR_ARG;
}

void sldbc_clear(sldbc_stmt *s) {
  if (s && s->s) ssql_reset(s->s);
}

sldbc_status sldbc_execute(sldbc_stmt *s) {
  if (!s || !s->s) return SLDBC_ERR_ARG;
  return ssql_run(s->s, NULL) == SSQL_OK ? SLDBC_OK : SLDBC_ERR_EXEC;
}

void sldbc_finalize(sldbc_stmt *s) {
  if (!s) return;
  if (s->s) ssql_finalize(s->s);
  free(s);
}

/* ---- CSV -> row set -------------------------------------------------- */
static void split_csv_line(const char *line, char ***out_fields, size_t *out_n) {
  size_t cap = 4, n = 0;
  char **f = (char **)malloc(cap * sizeof *f);
  if (!f) { *out_fields = NULL; *out_n = 0; return; }
  const char *p = line;
  const char *start = p;
  for (;; ++p) {
    if (*p == ',' || *p == 0) {
      size_t len = (size_t)(p - start);
      char *field = (char *)malloc(len + 1);
      if (field) { memcpy(field, start, len); field[len] = 0; }
      if (n >= cap) {
        cap *= 2;
        char **nf = (char **)realloc(f, cap * sizeof *f);
        if (!nf) { break; }
        f = nf;
      }
      f[n++] = field;
      start = p + 1;
      if (*p == 0) break;
    }
  }
  *out_fields = f;
  *out_n = n;
}

static sldbc_status parse_csv(const char *csv, sldbc_rows **out) {
  sldbc_rows *r = (sldbc_rows *)calloc(1, sizeof *r);
  if (!r) return SLDBC_ERR_OOM;

  /* Split into lines. */
  size_t cap_lines = 8, nlines = 0;
  char **lines = (char **)malloc(cap_lines * sizeof *lines);
  if (!lines) { free(r); return SLDBC_ERR_OOM; }
  const char *p = csv;
  while (*p) {
    const char *nl = strchr(p, '\n');
    size_t len = nl ? (size_t)(nl - p) : strlen(p);
    if (len && p[len - 1] == '\r') len--; /* tolerate CRLF */
    char *line = (char *)malloc(len + 1);
    if (line) { memcpy(line, p, len); line[len] = 0; }
    if (nlines >= cap_lines) {
      cap_lines *= 2;
      char **nls = (char **)realloc(lines, cap_lines * sizeof *lines);
      if (!nls) break;
      lines = nls;
    }
    lines[nlines++] = line;
    if (!nl) break;
    p = nl + 1;
  }

  if (nlines == 0) {
    /* empty result: zero columns, zero rows */
    free(lines);
    *out = r;
    return SLDBC_OK;
  }

  /* First line = header. */
  split_csv_line(lines[0], &r->cols, &r->ncols);
  if (nlines > 1) {
    r->cells = (char ***)calloc(nlines - 1, sizeof *r->cells);
    if (r->cells) {
      for (size_t i = 1; i < nlines; ++i) {
        char **fields = NULL;
        size_t nf = 0;
        split_csv_line(lines[i], &fields, &nf);
        /* normalize each row to ncols cells */
        char **row = (char **)calloc(r->ncols ? r->ncols : 1, sizeof *row);
        if (row) {
          for (size_t c = 0; c < r->ncols; ++c) {
            const char *v = c < nf ? fields[c] : "";
            char *dup = (char *)malloc(strlen(v) + 1);
            if (dup) strcpy(dup, v);
            row[c] = dup;
          }
        }
        for (size_t c = 0; c < nf; ++c) free(fields[c]);
        free(fields);
        r->cells[r->nrows++] = row;
      }
    }
  }

  for (size_t i = 0; i < nlines; ++i) free(lines[i]);
  free(lines);
  *out = r;
  return SLDBC_OK;
}

sldbc_status sldbc_query(sldbc_stmt *s, sldbc_rows **out) {
  if (!s || !s->s || !out) return SLDBC_ERR_ARG;
  *out = NULL;
  char *buf = NULL;
  size_t len = 0;
  FILE *mem = open_memstream(&buf, &len);
  ssql_status st = ssql_run(s->s, mem);
  if (mem) fclose(mem);
  if (st != SSQL_OK) {
    free(buf);
    return SLDBC_ERR_EXEC;
  }
  sldbc_status rc = parse_csv(buf ? buf : "", out);
  free(buf);
  return rc;
}

/* ---- row-set accessors ----------------------------------------------- */
size_t sldbc_rows_count(const sldbc_rows *r) { return r ? r->nrows : 0; }
size_t sldbc_rows_columns(const sldbc_rows *r) { return r ? r->ncols : 0; }

const char *sldbc_rows_column_name(const sldbc_rows *r, size_t col) {
  if (!r || col >= r->ncols) return NULL;
  return r->cols[col];
}

const char *sldbc_rows_value(const sldbc_rows *r, size_t row, size_t col) {
  if (!r || row >= r->nrows || col >= r->ncols) return NULL;
  if (!r->cells || !r->cells[row]) return NULL;
  return r->cells[row][col];
}

const char *sldbc_rows_value_named(const sldbc_rows *r, size_t row,
                                   const char *column) {
  if (!r || !column) return NULL;
  for (size_t c = 0; c < r->ncols; ++c)
    if (r->cols[c] && strcmp(r->cols[c], column) == 0)
      return sldbc_rows_value(r, row, c);
  return NULL;
}

void sldbc_rows_free(sldbc_rows *r) {
  if (!r) return;
  for (size_t c = 0; c < r->ncols; ++c) free(r->cols[c]);
  free(r->cols);
  for (size_t i = 0; i < r->nrows; ++i) {
    if (r->cells && r->cells[i]) {
      for (size_t c = 0; c < r->ncols; ++c) free(r->cells[i][c]);
      free(r->cells[i]);
    }
  }
  free(r->cells);
  free(r);
}

/* ---- transactions ---------------------------------------------------- */
sldbc_status sldbc_begin(sldbc_conn *c) {
  if (!c) return SLDBC_ERR_ARG;
  return ssql_begin(&c->db) == SSQL_OK ? SLDBC_OK : SLDBC_ERR_EXEC;
}
sldbc_status sldbc_commit(sldbc_conn *c) {
  if (!c) return SLDBC_ERR_ARG;
  return ssql_commit(&c->db) == SSQL_OK ? SLDBC_OK : SLDBC_ERR_EXEC;
}
sldbc_status sldbc_rollback(sldbc_conn *c) {
  if (!c) return SLDBC_ERR_ARG;
  return ssql_rollback(&c->db) == SSQL_OK ? SLDBC_OK : SLDBC_ERR_EXEC;
}

/* ---- diagnostics ----------------------------------------------------- */
const char *sldbc_strerror(sldbc_status s) {
  switch (s) {
    case SLDBC_OK: return "ok";
    case SLDBC_ERR_ARG: return "bad argument";
    case SLDBC_ERR_URL: return "malformed connection url";
    case SLDBC_ERR_NODRIVER: return "no driver for scheme";
    case SLDBC_UNSUPPORTED: return "driver not yet implemented";
    case SLDBC_ERR_OPEN: return "backend open failed";
    case SLDBC_ERR_EXEC: return "statement failed";
    case SLDBC_ERR_RANGE: return "index out of range";
    case SLDBC_ERR_OOM: return "out of memory";
    default: return "unknown error";
  }
}