/*
* sleela_sql.c -- CSV-backed MySQL-subset engine (C implementation).
* Part of mearvk/Nintendo.
*
* Architecture: parse -> compiled IR (ssql_stmt) -> execute.
*
* Surface language Compiler Compiled IR Executor
* ---------------- ------------------- ------------- -------------------
* SQL --> compile_sql() \
* >--> ssql_stmt --> exec_stmt()
* SLeeLaSQL --> compile_sleela() /
*
* Both dialects lower to the SAME ssql_stmt, so they are feature-complete with
* each other and share one executor. A compiled statement can carry '?'
* placeholders and be re-bound and re-run -- the PreparedStatement speed-up.
*
* Storage model: one CSV file per table (
/.csv). The first line is
* the header (column names); each following line is a record.
*/
#include "sleela_sql.h"
#include
#include
#include
#include
#include
#ifdef _WIN32
# include
# include
# define strcasecmp _stricmp
# define SSQL_MKDIR(path) _mkdir(path)
# ifndef S_IFMT
# define S_IFMT _S_IFMT
# endif
# ifndef S_IFDIR
# define S_IFDIR _S_IFDIR
# endif
#else
# include
# include
# include
# define SSQL_MKDIR(path) mkdir((path), 0775)
#endif
/* ===================================================================== *
* Small string helpers
* ===================================================================== */
static char *str_dup(const char *s) {
size_t n = strlen(s) + 1;
char *p = (char *)malloc(n);
if (p) memcpy(p, s, n);
return p;
}
/* Trim leading/trailing ASCII whitespace in place; returns the start. */
static char *trim(char *s) {
while (*s && isspace((unsigned char)*s)) s++;
char *end = s + strlen(s);
while (end > s && isspace((unsigned char)end[-1])) *--end = '\0';
return s;
}
/* Case-insensitive keyword compare of the first word of `s`. */
static int kw_eq(const char *s, const char *kw) {
size_t n = strlen(kw);
for (size_t i = 0; i < n; i++) {
if (tolower((unsigned char)s[i]) != tolower((unsigned char)kw[i])) return 0;
}
char c = s[n];
return (c == '\0' || isspace((unsigned char)c) || c == '(' || c == '*' || c == ';');
}
/* Strip one matching pair of surrounding single/double quotes, in place. */
static char *unquote(char *s) {
size_t n = strlen(s);
if (n >= 2 && ((s[0] == '\'' && s[n - 1] == '\'') ||
(s[0] == '"' && s[n - 1] == '"'))) {
s[n - 1] = '\0';
return s + 1;
}
return s;
}
/*
* Split `s` on top-level commas (commas not inside single/double quotes) into
* up to `max` trimmed+unquoted fields. Mutates `s`. Returns the field count.
*/
static int split_fields(char *s, char **out, int max) {
int n = 0;
char *start = s;
char quote = 0;
for (char *p = s;; p++) {
if (quote) {
if (*p == quote) quote = 0;
} else if (*p == '\'' || *p == '"') {
quote = *p;
} else if (*p == ',' || *p == '\0') {
char save = *p;
*p = '\0';
if (n < max) {
char *f = trim(start);
out[n++] = unquote(f);
}
if (save == '\0') break;
start = p + 1;
}
}
return n;
}
/* ===================================================================== *
* CSV field I/O
* ===================================================================== */
/* Write one CSV field, quoting only if it contains comma, quote, or newline. */
static void csv_write_field(FILE *out, const char *v) {
int needs = 0;
for (const char *p = v; *p; p++) {
if (*p == ',' || *p == '"' || *p == '\n' || *p == '\r') { needs = 1; break; }
}
if (!needs) { fputs(v, out); return; }
fputc('"', out);
for (const char *p = v; *p; p++) {
if (*p == '"') fputc('"', out);
fputc(*p, out);
}
fputc('"', out);
}
static void csv_write_row(FILE *out, char **fields, int n) {
for (int i = 0; i < n; i++) {
if (i) fputc(',', out);
csv_write_field(out, fields[i]);
}
fputc('\n', out);
}
/*
* Parse one CSV line into up to `max` fields (NUL-terminated, dequoted).
* `line` is mutated. Returns field count.
*/
static int csv_parse_line(char *line, char **out, int max) {
size_t n = strlen(line);
while (n && (line[n - 1] == '\n' || line[n - 1] == '\r')) line[--n] = '\0';
int count = 0;
char *w = line;
char *field = line;
int in_quotes = 0;
char *p = line;
for (;; p++) {
char c = *p;
if (in_quotes) {
if (c == '"') {
if (p[1] == '"') { *w++ = '"'; p++; }
else in_quotes = 0;
} else if (c == '\0') {
break;
} else {
*w++ = c;
}
} else {
if (c == '"') {
in_quotes = 1;
} else if (c == ',' || c == '\0') {
*w = '\0';
if (count < max) out[count++] = field;
if (c == '\0') break;
w++;
field = w;
} else {
*w++ = c;
}
}
}
return count;
}
/* ===================================================================== *
* Path helpers
* ===================================================================== */
/* dir (<=SSQL_MAX_FIELD) + '/' + name (<=SSQL_MAX_FIELD) + ".csv" + NUL */
#define SSQL_MAX_PATH (SSQL_MAX_FIELD * 2 + 8)
/* A transaction journal path is /, so
* it needs room for a full path plus another filename. */
#define SSQL_MAX_TXN_PATH (SSQL_MAX_PATH + SSQL_MAX_FIELD + 8)
static void table_path(const ssql_db *db, const char *name, char *buf, size_t cap) {
snprintf(buf, cap, "%s/%s.csv", db->dir, name);
}
static int valid_table_name(const char *name) {
if (!name || !(((*name >= 'A') && (*name <= 'Z')) || ((*name >= 'a') && (*name <= 'z')) || *name == '_')) return 0;
for (const unsigned char *p = (const unsigned char *)name + 1; *p; ++p) {
if (!((*p >= 'A' && *p <= 'Z') || (*p >= 'a' && *p <= 'z') || (*p >= '0' && *p <= '9') || *p == '_' || *p == '-')) return 0;
}
return 1;
}
static int valid_column_name(const char *name) {
if (!name || !*name) return 0;
unsigned char first = (unsigned char)name[0];
if (!((first >= 'A' && first <= 'Z') ||
(first >= 'a' && first <= 'z') || first == '_')) return 0;
for (const unsigned char *p = (const unsigned char *)name + 1; *p; ++p)
if (!((*p >= 'A' && *p <= 'Z') || (*p >= 'a' && *p <= 'z') ||
(*p >= '0' && *p <= '9') || *p == '_' || *p == '-')) return 0;
return 1;
}
static int table_exists(const ssql_db *db, const char *name) {
char path[SSQL_MAX_PATH];
table_path(db, name, path, sizeof(path));
FILE *f = fopen(path, "rb");
if (f) { fclose(f); return 1; }
return 0;
}
static int find_col(char **cols, int ncols, const char *name) {
for (int i = 0; i < ncols; i++)
if (strcasecmp(cols[i], name) == 0) return i;
return -1;
}
/* ===================================================================== *
* Compiled statement IR
* ===================================================================== */
typedef enum {
OP_CREATE, /* CREATE TABLE */
OP_ALTER, /* ALTER TABLE ADD COLUMN */
OP_DROP, /* DROP TABLE */
OP_INSERT, /* INSERT */
OP_UPDATE, /* UPDATE */
OP_DELETE, /* DELETE */
OP_SELECT, /* SELECT */
OP_SHOW_TABLES /* SHOW TABLES */
} ssql_op;
/*
* A value slot is either a literal or a '?' placeholder. For placeholders,
* `param` is the 1-based parameter index; `lit` holds the bound value (or NULL
* until bound). For literals, `param` is 0 and `lit` is the literal text.
*/
typedef struct {
int param; /* 1-based placeholder index, or 0 for a literal */
char *lit; /* literal text, or bound value for a placeholder */
} ssql_val;
struct ssql_stmt {
ssql_db *db;
ssql_op op;
char table[SSQL_MAX_FIELD];
/* CREATE: column names. SELECT: projection ("*" => star=1). */
char *cols[SSQL_MAX_COLS];
int ncols;
int star; /* SELECT * */
/* INSERT values (literals and/or placeholders). */
ssql_val vals[SSQL_MAX_COLS];
int nvals;
/* WHERE = (equality only). */
int have_where;
char where_col[SSQL_MAX_FIELD];
ssql_val where_val;
int drop_if_exists;
int create_if_not_exists;
int count_star;
int nparams; /* total '?' placeholders */
};
static void val_free(ssql_val *v) {
if (v && v->lit) { free(v->lit); v->lit = NULL; }
}
void ssql_finalize(ssql_stmt *stmt) {
if (!stmt) return;
for (int i = 0; i < stmt->ncols; i++) free(stmt->cols[i]);
for (int i = 0; i < stmt->nvals; i++) val_free(&stmt->vals[i]);
val_free(&stmt->where_val);
free(stmt);
}
/* Build an empty, zeroed statement bound to `db`. */
static ssql_stmt *stmt_new(ssql_db *db) {
ssql_stmt *s = (ssql_stmt *)calloc(1, sizeof(*s));
if (s) s->db = db;
return s;
}
/*
* Set a value slot from raw token text. A bare "?" becomes a placeholder and is
* assigned the next parameter index; anything else is stored as a literal
* (quotes already stripped by split_fields). Returns 0 on OK, -1 on OOM.
*/
static int val_set(ssql_stmt *st, ssql_val *v, const char *token) {
if (strcmp(token, "?") == 0) {
v->param = ++st->nparams;
v->lit = NULL; /* unbound until ssql_bind */
return 0;
}
v->param = 0;
v->lit = str_dup(token);
return v->lit ? 0 : -1;
}
/* ===================================================================== *
* SQL compiler (text -> ssql_stmt)
* ===================================================================== */
/* CREATE TABLE (, , ...) */
static ssql_status sql_create(ssql_stmt *st, char *rest) {
if (kw_eq(rest, "if")) {
rest = trim(rest + 2);
if (!kw_eq(rest, "not")) return SSQL_ERR_SYNTAX;
rest = trim(rest + 3);
if (!kw_eq(rest, "exists")) return SSQL_ERR_SYNTAX;
rest = trim(rest + 6);
st->create_if_not_exists = 1;
}
char *lp = strchr(rest, '(');
char *rp = strrchr(rest, ')');
if (!lp || !rp || rp < lp) return SSQL_ERR_SYNTAX;
*lp = '\0';
char *name = trim(rest);
if (!*name) return SSQL_ERR_SYNTAX;
snprintf(st->table, sizeof(st->table), "%s", name);
*rp = '\0';
char *cols[SSQL_MAX_COLS];
int ncols = split_fields(lp + 1, cols, SSQL_MAX_COLS);
if (ncols < 1) return SSQL_ERR_SYNTAX;
for (int i = 0; i < ncols; i++) {
st->cols[i] = str_dup(cols[i]);
if (!st->cols[i]) return SSQL_ERR_OOM;
}
st->ncols = ncols;
st->op = OP_CREATE;
return SSQL_OK;
}
/* ALTER TABLE ADD [COLUMN] [DEFAULT ] */
static ssql_status sql_alter(ssql_stmt *st, char *rest) {
char *name = trim(rest), *space = name;
while (*space && !isspace((unsigned char)*space)) space++;
if (!*space) return SSQL_ERR_SYNTAX;
*space++ = '\0';
if (!valid_table_name(name)) return SSQL_ERR_SYNTAX;
snprintf(st->table, sizeof(st->table), "%s", name);
rest = trim(space);
if (!kw_eq(rest, "add")) return SSQL_ERR_SYNTAX;
rest = trim(rest + 3);
if (kw_eq(rest, "column")) rest = trim(rest + 6);
char *end = rest;
while (*end && !isspace((unsigned char)*end)) end++;
if (end == rest) return SSQL_ERR_SYNTAX;
char saved = *end;
*end = '\0';
if (!valid_column_name(rest)) return SSQL_ERR_SYNTAX;
st->cols[0] = str_dup(rest);
if (!st->cols[0]) return SSQL_ERR_OOM;
st->ncols = 1;
*end = saved;
rest = trim(end);
const char *default_value = "";
if (*rest) {
if (!kw_eq(rest, "default")) return SSQL_ERR_SYNTAX;
rest = trim(rest + 7);
if (!*rest) return SSQL_ERR_SYNTAX;
default_value = unquote(rest);
}
if (val_set(st, &st->vals[0], default_value) != 0) return SSQL_ERR_OOM;
st->nvals = 1;
st->op = OP_ALTER;
return SSQL_OK;
}
/* DROP TABLE [IF EXISTS] */
static ssql_status sql_drop(ssql_stmt *st, char *rest) {
char *name = trim(rest);
if (kw_eq(name, "if")) {
name = trim(name + 2);
if (kw_eq(name, "exists")) { name = trim(name + 6); st->drop_if_exists = 1; }
}
if (!*name) return SSQL_ERR_SYNTAX;
snprintf(st->table, sizeof(st->table), "%s", name);
st->op = OP_DROP;
return SSQL_OK;
}
/* INSERT INTO [(c,...)] VALUES (v,...) */
static ssql_status sql_insert(ssql_stmt *st, char *rest) {
if (!kw_eq(rest, "into")) return SSQL_ERR_SYNTAX;
rest = trim(rest + 4);
char *vpos = rest;
while (*vpos && !kw_eq(vpos, "values")) vpos++;
if (!*vpos) return SSQL_ERR_SYNTAX;
char nameseg[SSQL_MAX_FIELD];
size_t seglen = (size_t)(vpos - rest);
if (seglen >= sizeof(nameseg)) return SSQL_ERR_SYNTAX;
memcpy(nameseg, rest, seglen);
nameseg[seglen] = '\0';
char *paren = strchr(nameseg, '(');
if (paren) *paren = '\0'; /* positional insert; column list ignored */
char *name = trim(nameseg);
if (!*name) return SSQL_ERR_SYNTAX;
snprintf(st->table, sizeof(st->table), "%s", name);
char *lp = strchr(vpos, '(');
char *rp = strrchr(vpos, ')');
if (!lp || !rp || rp < lp) return SSQL_ERR_SYNTAX;
*rp = '\0';
char *vals[SSQL_MAX_COLS];
int nvals = split_fields(lp + 1, vals, SSQL_MAX_COLS);
if (nvals < 1) return SSQL_ERR_SYNTAX;
for (int i = 0; i < nvals; i++)
if (val_set(st, &st->vals[i], vals[i]) != 0) return SSQL_ERR_OOM;
st->nvals = nvals;
st->op = OP_INSERT;
return SSQL_OK;
}
/* Parse " = " into st->where_*. `expr` is mutated. */
static ssql_status parse_where(ssql_stmt *st, char *expr) {
char *eq = strchr(expr, '=');
if (!eq) return SSQL_ERR_SYNTAX;
*eq = '\0';
char *wc = trim(expr);
char *wv = trim(eq + 1);
if (!*wc) return SSQL_ERR_SYNTAX;
snprintf(st->where_col, sizeof(st->where_col), "%s", wc);
if (strcmp(wv, "?") != 0) wv = unquote(wv);
if (val_set(st, &st->where_val, wv) != 0) return SSQL_ERR_OOM;
st->have_where = 1;
return SSQL_OK;
}
/* SELECT * | c,... FROM [WHERE col = value] */
static ssql_status sql_select(ssql_stmt *st, char *rest) {
char *fpos = rest;
while (*fpos && !kw_eq(fpos, "from")) fpos++;
if (!*fpos) return SSQL_ERR_SYNTAX;
char projbuf[SSQL_MAX_FIELD];
size_t plen = (size_t)(fpos - rest);
if (plen >= sizeof(projbuf)) return SSQL_ERR_SYNTAX;
memcpy(projbuf, rest, plen);
projbuf[plen] = '\0';
char *proj = trim(projbuf);
char *after = trim(fpos + 4);
char *wpos = after;
while (*wpos && !kw_eq(wpos, "where")) wpos++;
char namebuf[SSQL_MAX_FIELD];
size_t nlen = (size_t)(wpos - after);
if (nlen >= sizeof(namebuf)) return SSQL_ERR_SYNTAX;
memcpy(namebuf, after, nlen);
namebuf[nlen] = '\0';
char *name = trim(namebuf);
if (!*name) return SSQL_ERR_SYNTAX;
snprintf(st->table, sizeof(st->table), "%s", name);
if (strcasecmp(proj, "count(*)") == 0) {
st->count_star = 1;
} else if (strcmp(proj, "*") == 0) {
st->star = 1;
} else {
char *pcols[SSQL_MAX_COLS];
int np = split_fields(proj, pcols, SSQL_MAX_COLS);
if (np < 1) return SSQL_ERR_SYNTAX;
for (int i = 0; i < np; i++) {
st->cols[i] = str_dup(pcols[i]);
if (!st->cols[i]) return SSQL_ERR_OOM;
}
st->ncols = np;
}
if (*wpos) {
char *expr = trim(wpos + 5);
ssql_status s = parse_where(st, expr);
if (s != SSQL_OK) return s;
}
st->op = OP_SELECT;
return SSQL_OK;
}
/* UPDATE SET c=v [, c=v ...] [WHERE c = v] */
static ssql_status sql_update(ssql_stmt *st, char *rest) {
char *setpos = rest;
while (*setpos && !((setpos == rest || isspace((unsigned char)setpos[-1])) &&
kw_eq(setpos, "set"))) setpos++;
if (!*setpos) return SSQL_ERR_SYNTAX;
*setpos = '\0';
char *name = trim(rest);
if (!*name || strlen(name) >= sizeof(st->table)) return SSQL_ERR_SYNTAX;
snprintf(st->table, sizeof(st->table), "%s", name);
char *assignments = trim(setpos + 3);
char *wpos = assignments;
while (*wpos && !((wpos == assignments || isspace((unsigned char)wpos[-1])) &&
kw_eq(wpos, "where"))) wpos++;
char assignbuf[SSQL_MAX_FIELD];
size_t alen = (size_t)(wpos - assignments);
if (alen == 0 || alen >= sizeof(assignbuf)) return SSQL_ERR_SYNTAX;
memcpy(assignbuf, assignments, alen);
assignbuf[alen] = '\0';
char *items[SSQL_MAX_COLS];
int n = split_fields(assignbuf, items, SSQL_MAX_COLS);
if (n < 1) return SSQL_ERR_SYNTAX;
for (int i = 0; i < n; ++i) {
char *eq = strchr(items[i], '=');
if (!eq) return SSQL_ERR_SYNTAX;
*eq = '\0';
char *col = trim(items[i]);
char *value = trim(eq + 1);
if (!*col || !*value) return SSQL_ERR_SYNTAX;
st->cols[i] = str_dup(col);
if (!st->cols[i]) return SSQL_ERR_OOM;
value = unquote(value);
if (val_set(st, &st->vals[i], value) != 0) return SSQL_ERR_OOM;
st->ncols++;
st->nvals++;
}
if (*wpos) {
ssql_status status = parse_where(st, trim(wpos + 5));
if (status != SSQL_OK) return status;
}
st->op = OP_UPDATE;
return SSQL_OK;
}
/* DELETE FROM [WHERE c = v] */
static ssql_status sql_delete(ssql_stmt *st, char *rest) {
if (!kw_eq(rest, "from")) return SSQL_ERR_SYNTAX;
rest = trim(rest + 4);
char *wpos = rest;
while (*wpos && !((wpos == rest || isspace((unsigned char)wpos[-1])) &&
kw_eq(wpos, "where"))) wpos++;
char namebuf[SSQL_MAX_FIELD];
size_t n = (size_t)(wpos - rest);
if (!n || n >= sizeof(namebuf)) return SSQL_ERR_SYNTAX;
memcpy(namebuf, rest, n);
namebuf[n] = '\0';
char *name = trim(namebuf);
if (!*name || strlen(name) >= sizeof(st->table)) return SSQL_ERR_SYNTAX;
snprintf(st->table, sizeof(st->table), "%s", name);
if (*wpos) {
ssql_status status = parse_where(st, trim(wpos + 5));
if (status != SSQL_OK) return status;
}
st->op = OP_DELETE;
return SSQL_OK;
}
static ssql_status compile_sql(ssql_stmt *st, char *stmt) {
if (kw_eq(stmt, "create")) {
char *r = trim(stmt + 6);
if (!kw_eq(r, "table")) return SSQL_ERR_SYNTAX;
return sql_create(st, trim(r + 5));
}
if (kw_eq(stmt, "alter")) {
char *r = trim(stmt + 5);
if (!kw_eq(r, "table")) return SSQL_ERR_SYNTAX;
return sql_alter(st, trim(r + 5));
}
if (kw_eq(stmt, "drop")) {
char *r = trim(stmt + 4);
if (!kw_eq(r, "table")) return SSQL_ERR_SYNTAX;
return sql_drop(st, trim(r + 5));
}
if (kw_eq(stmt, "insert")) return sql_insert(st, trim(stmt + 6));
if (kw_eq(stmt, "update")) return sql_update(st, trim(stmt + 6));
if (kw_eq(stmt, "delete")) return sql_delete(st, trim(stmt + 6));
if (kw_eq(stmt, "select")) return sql_select(st, trim(stmt + 6));
if (kw_eq(stmt, "show")) {
char *r = trim(stmt + 4);
if (kw_eq(r, "tables")) { st->op = OP_SHOW_TABLES; return SSQL_OK; }
return SSQL_ERR_SYNTAX;
}
return SSQL_ERR_SYNTAX;
}
/* ===================================================================== *
* SLeeLaSQL compiler (fluent dialect -> ssql_stmt)
*
* Grammar (dot-chained calls; '?' is a placeholder):
*
* table("games").create(id, title, year)
* into("games").insert(?, ?, ?)
* from("games").select(title, year).where(year == ?)
* from("games").select(*)
* from("games").drop() // or drop(ifExists)
* tables()
*
* It is deliberately a thin, 1:1 lowering onto the same IR as SQL -- same
* features, same executor, same placeholders -- just a cleaner surface.
* ===================================================================== */
/* Pull the argument text inside the FIRST (...) that follows `*pp`. Advances
* `*pp` past the closing ')'. Writes a NUL-terminated copy into `out`. */
static int take_parens(char **pp, char *out, size_t cap) {
char *p = *pp;
while (*p && *p != '(') p++;
if (*p != '(') return -1;
p++;
int depth = 1;
char quote = 0;
size_t n = 0;
while (*p) {
char c = *p;
if (quote) { if (c == quote) quote = 0; }
else if (c == '\'' || c == '"') quote = c;
else if (c == '(') depth++;
else if (c == ')') { depth--; if (depth == 0) { p++; break; } }
if (depth == 0) break;
if (n + 1 < cap) out[n++] = c;
p++;
}
out[n] = '\0';
*pp = p;
return 0;
}
/* Read the chain method name at `*pp` (letters), lower-cased into `out`. */
static int take_method(char **pp, char *out, size_t cap) {
char *p = *pp;
while (*p == '.' || isspace((unsigned char)*p)) p++;
size_t n = 0;
while (isalpha((unsigned char)*p)) {
if (n + 1 < cap) out[n++] = (char)tolower((unsigned char)*p);
p++;
}
out[n] = '\0';
*pp = p;
return n > 0 ? 0 : -1;
}
/* Translate "a == b" / "a = b" inside a where(...) to the shared parser form. */
static ssql_status sleela_where(ssql_stmt *st, char *expr) {
/* accept '==' by collapsing to '=' */
char *dd = strstr(expr, "==");
if (dd) { dd[0] = '='; memmove(dd + 1, dd + 2, strlen(dd + 2) + 1); }
return parse_where(st, expr);
}
static ssql_status compile_sleela(ssql_stmt *st, char *src) {
char method[64];
char args[SSQL_MAX_FIELD];
char *p = src;
if (take_method(&p, method, sizeof(method)) != 0) return SSQL_ERR_SYNTAX;
if (strcmp(method, "tables") == 0) {
st->op = OP_SHOW_TABLES;
return SSQL_OK;
}
/* The three roots that carry a table name: table(...), into(...), from(...) */
int is_table = (strcmp(method, "table") == 0);
int is_into = (strcmp(method, "into") == 0);
int is_from = (strcmp(method, "from") == 0);
if (!is_table && !is_into && !is_from) return SSQL_ERR_SYNTAX;
if (take_parens(&p, args, sizeof(args)) != 0) return SSQL_ERR_SYNTAX;
{
char *nm = unquote(trim(args));
if (!*nm) return SSQL_ERR_SYNTAX;
snprintf(st->table, sizeof(st->table), "%s", nm);
}
/* second method: the verb */
if (take_method(&p, method, sizeof(method)) != 0) return SSQL_ERR_SYNTAX;
if (is_table && strcmp(method, "create") == 0) {
if (take_parens(&p, args, sizeof(args)) != 0) return SSQL_ERR_SYNTAX;
char *cols[SSQL_MAX_COLS];
int nc = split_fields(args, cols, SSQL_MAX_COLS);
if (nc < 1) return SSQL_ERR_SYNTAX;
for (int i = 0; i < nc; i++) {
st->cols[i] = str_dup(cols[i]);
if (!st->cols[i]) return SSQL_ERR_OOM;
}
st->ncols = nc;
st->op = OP_CREATE;
return SSQL_OK;
}
if (is_from && strcmp(method, "drop") == 0) {
if (take_parens(&p, args, sizeof(args)) != 0) return SSQL_ERR_SYNTAX;
char *a = trim(args);
if (strcasecmp(a, "ifexists") == 0 || strcasecmp(a, "if_exists") == 0)
st->drop_if_exists = 1;
st->op = OP_DROP;
return SSQL_OK;
}
if (is_into && strcmp(method, "insert") == 0) {
if (take_parens(&p, args, sizeof(args)) != 0) return SSQL_ERR_SYNTAX;
char *vals[SSQL_MAX_COLS];
int nv = split_fields(args, vals, SSQL_MAX_COLS);
if (nv < 1) return SSQL_ERR_SYNTAX;
for (int i = 0; i < nv; i++)
if (val_set(st, &st->vals[i], vals[i]) != 0) return SSQL_ERR_OOM;
st->nvals = nv;
st->op = OP_INSERT;
return SSQL_OK;
}
if (is_from && strcmp(method, "select") == 0) {
if (take_parens(&p, args, sizeof(args)) != 0) return SSQL_ERR_SYNTAX;
char *proj = trim(args);
if (strcasecmp(proj, "count(*)") == 0) {
st->count_star = 1;
} else if (strcmp(proj, "*") == 0 || *proj == '\0') {
st->star = 1;
} else {
char *pcols[SSQL_MAX_COLS];
int np = split_fields(proj, pcols, SSQL_MAX_COLS);
if (np < 1) return SSQL_ERR_SYNTAX;
for (int i = 0; i < np; i++) {
st->cols[i] = str_dup(pcols[i]);
if (!st->cols[i]) return SSQL_ERR_OOM;
}
st->ncols = np;
}
st->op = OP_SELECT;
/* optional trailing .where(...) */
char saved[64];
char *probe = p;
if (take_method(&probe, saved, sizeof(saved)) == 0 &&
strcmp(saved, "where") == 0) {
p = probe;
if (take_parens(&p, args, sizeof(args)) != 0) return SSQL_ERR_SYNTAX;
ssql_status s = sleela_where(st, trim(args));
if (s != SSQL_OK) return s;
}
return SSQL_OK;
}
return SSQL_ERR_SYNTAX;
}
/* ===================================================================== *
* Dialect sniffing
* ===================================================================== */
/*
* Heuristic: SLeeLaSQL always begins with one of its fluent roots --
* table(, into(, from(, tables( -- so a statement whose first identifier is one
* of those and is immediately followed by '(' is SLeeLaSQL. Everything else is
* treated as SQL. (AUTO only; callers can force a dialect.)
*/
static ssql_dialect sniff(const char *stmt) {
const char *p = stmt;
while (*p && isspace((unsigned char)*p)) p++;
char word[16];
size_t n = 0;
while (isalpha((unsigned char)*p) && n + 1 < sizeof(word))
word[n++] = (char)tolower((unsigned char)*p++);
word[n] = '\0';
while (*p && isspace((unsigned char)*p)) p++;
if (*p != '(') return SSQL_DIALECT_SQL;
if (!strcmp(word, "table") || !strcmp(word, "into") ||
!strcmp(word, "from") || !strcmp(word, "tables"))
return SSQL_DIALECT_SLEELA;
return SSQL_DIALECT_SQL;
}
/* ===================================================================== *
* Executor (ssql_stmt -> effect / rows)
* ===================================================================== */
/* Resolve a value slot to its effective string (literal or bound value). */
static ssql_status val_resolve(const ssql_val *v, const char **out) {
if (v->param != 0 && v->lit == NULL) return SSQL_ERR_BIND;
*out = v->lit ? v->lit : "";
return SSQL_OK;
}
static ssql_status exec_create(ssql_stmt *st) {
if (table_exists(st->db, st->table)) return st->create_if_not_exists ? SSQL_OK : SSQL_ERR_EXISTS;
char path[SSQL_MAX_PATH];
table_path(st->db, st->table, path, sizeof(path));
FILE *f = fopen(path, "wb");
if (!f) return SSQL_ERR_IO;
csv_write_row(f, st->cols, st->ncols);
fclose(f);
return SSQL_OK;
}
static ssql_status replace_table_file(const char *tmp, const char *path);
static ssql_status exec_alter(ssql_stmt *st) {
const char *default_value = "";
ssql_status status = val_resolve(&st->vals[0], &default_value);
if (status != SSQL_OK) return status;
char path[SSQL_MAX_PATH], tmp[SSQL_MAX_PATH];
table_path(st->db, st->table, path, sizeof(path));
if (snprintf(tmp, sizeof(tmp), "%s.tmp", path) >= (int)sizeof(tmp)) return SSQL_ERR_IO;
FILE *in = fopen(path, "rb");
if (!in) return SSQL_ERR_NOTABLE;
FILE *out = fopen(tmp, "wb");
if (!out) { fclose(in); return SSQL_ERR_IO; }
char line[SSQL_MAX_FIELD * 8];
char *fields[SSQL_MAX_COLS];
if (!fgets(line, sizeof(line), in)) {
fclose(in); fclose(out); remove(tmp); return SSQL_ERR_IO;
}
int ncolumns = csv_parse_line(line, fields, SSQL_MAX_COLS);
if (ncolumns < 1) {
fclose(in); fclose(out); remove(tmp); return SSQL_ERR_IO;
}
if (ncolumns >= SSQL_MAX_COLS) {
fclose(in); fclose(out); remove(tmp); return SSQL_ERR_ARITY;
}
if (find_col(fields, ncolumns, st->cols[0]) >= 0) {
fclose(in); fclose(out); remove(tmp); return SSQL_ERR_DUPCOL;
}
fields[ncolumns] = st->cols[0];
csv_write_row(out, fields, ncolumns + 1);
while (fgets(line, sizeof(line), in)) {
int nfields = csv_parse_line(line, fields, SSQL_MAX_COLS);
if (nfields != ncolumns) {
fclose(in); fclose(out); remove(tmp); return SSQL_ERR_IO;
}
fields[ncolumns] = (char *)default_value;
csv_write_row(out, fields, ncolumns + 1);
}
int input_error = ferror(in), output_error = ferror(out);
if (fclose(out) != 0) output_error = 1;
fclose(in);
if (input_error || output_error) { remove(tmp); return SSQL_ERR_IO; }
status = replace_table_file(tmp, path);
if (status != SSQL_OK) remove(tmp);
return status;
}
static ssql_status exec_drop(ssql_stmt *st) {
if (!table_exists(st->db, st->table))
return st->drop_if_exists ? SSQL_OK : SSQL_ERR_NOTABLE;
char path[SSQL_MAX_PATH];
table_path(st->db, st->table, path, sizeof(path));
return remove(path) == 0 ? SSQL_OK : SSQL_ERR_IO;
}
static ssql_status exec_insert(ssql_stmt *st) {
/* arity check against the stored header */
char path[SSQL_MAX_PATH];
table_path(st->db, st->table, path, sizeof(path));
FILE *f = fopen(path, "rb");
if (!f) return SSQL_ERR_NOTABLE;
char hdr[SSQL_MAX_FIELD * 8];
char *cols[SSQL_MAX_COLS];
int ncols = 0;
if (fgets(hdr, sizeof(hdr), f)) ncols = csv_parse_line(hdr, cols, SSQL_MAX_COLS);
fclose(f);
if (st->nvals != ncols) return SSQL_ERR_ARITY;
/* resolve each value (literal or bound placeholder) */
const char *resolved[SSQL_MAX_COLS];
for (int i = 0; i < st->nvals; i++) {
ssql_status s = val_resolve(&st->vals[i], &resolved[i]);
if (s != SSQL_OK) return s;
}
f = fopen(path, "ab");
if (!f) return SSQL_ERR_IO;
csv_write_row(f, (char **)resolved, st->nvals);
fclose(f);
return SSQL_OK;
}
static ssql_status exec_select(ssql_stmt *st, FILE *out) {
const char *where_val = NULL;
if (st->have_where) {
ssql_status s = val_resolve(&st->where_val, &where_val);
if (s != SSQL_OK) return s;
}
char path[SSQL_MAX_PATH];
table_path(st->db, st->table, path, sizeof(path));
FILE *f = fopen(path, "rb");
if (!f) return SSQL_ERR_NOTABLE;
char line[SSQL_MAX_FIELD * 8];
char hdrbuf[SSQL_MAX_FIELD * 8];
char *cols[SSQL_MAX_COLS];
int ncols = 0;
if (fgets(hdrbuf, sizeof(hdrbuf), f)) ncols = csv_parse_line(hdrbuf, cols, SSQL_MAX_COLS);
int proj_idx[SSQL_MAX_COLS];
int nproj = 0;
if (st->star) {
for (int i = 0; i < ncols; i++) proj_idx[nproj++] = i;
} else {
for (int i = 0; i < st->ncols; i++) {
int idx = find_col(cols, ncols, st->cols[i]);
if (idx < 0) { fclose(f); return SSQL_ERR_NOCOL; }
proj_idx[nproj++] = idx;
}
}
int where_idx = -1;
if (st->have_where) {
where_idx = find_col(cols, ncols, st->where_col);
if (where_idx < 0) { fclose(f); return SSQL_ERR_NOCOL; }
}
long long count = 0;
if (out && !st->count_star) {
for (int i = 0; i < nproj; i++) {
if (i) fputc(',', out);
csv_write_field(out, cols[proj_idx[i]]);
}
fputc('\n', out);
}
while (fgets(line, sizeof(line), f)) {
char rowtmp[SSQL_MAX_FIELD * 8];
snprintf(rowtmp, sizeof(rowtmp), "%s", line);
char *fields[SSQL_MAX_COLS];
int nf = csv_parse_line(rowtmp, fields, SSQL_MAX_COLS);
if (nf == 0) continue;
if (st->have_where) {
if (where_idx >= nf) continue;
if (strcmp(fields[where_idx], where_val) != 0) continue;
}
if (st->count_star) { count++; continue; }
if (out) {
for (int i = 0; i < nproj; i++) {
if (i) fputc(',', out);
int idx = proj_idx[i];
csv_write_field(out, idx < nf ? fields[idx] : "");
}
fputc('\n', out);
}
}
fclose(f);
if (st->count_star && out) fprintf(out, "COUNT(*)\n%lld\n", count);
return SSQL_OK;
}
/* Replace a rewritten table safely on POSIX and with rollback on Windows. */
static ssql_status replace_table_file(const char *tmp, const char *path) {
#ifdef _WIN32
char backup[SSQL_MAX_PATH];
if (snprintf(backup, sizeof(backup), "%s.bak", path) >= (int)sizeof(backup))
return SSQL_ERR_IO;
(void)remove(backup);
if (rename(path, backup) != 0) return SSQL_ERR_IO;
if (rename(tmp, path) != 0) {
(void)rename(backup, path);
return SSQL_ERR_IO;
}
(void)remove(backup);
#else
if (rename(tmp, path) != 0) return SSQL_ERR_IO;
#endif
return SSQL_OK;
}
/* UPDATE and DELETE share a bounded, streaming CSV rewrite. */
static ssql_status exec_rewrite(ssql_stmt *st, int deleting) {
const char *where_value = NULL;
if (st->have_where) {
ssql_status status = val_resolve(&st->where_val, &where_value);
if (status != SSQL_OK) return status;
}
const char *set_values[SSQL_MAX_COLS];
if (!deleting) {
for (int i = 0; i < st->nvals; ++i) {
ssql_status status = val_resolve(&st->vals[i], &set_values[i]);
if (status != SSQL_OK) return status;
}
}
char path[SSQL_MAX_PATH], tmp[SSQL_MAX_PATH];
table_path(st->db, st->table, path, sizeof(path));
if (snprintf(tmp, sizeof(tmp), "%s.tmp", path) >= (int)sizeof(tmp))
return SSQL_ERR_IO;
FILE *in = fopen(path, "rb");
if (!in) return SSQL_ERR_NOTABLE;
FILE *out = fopen(tmp, "wb");
if (!out) { fclose(in); return SSQL_ERR_IO; }
char line[SSQL_MAX_FIELD * 8];
char *columns[SSQL_MAX_COLS];
int ncolumns = 0;
if (!fgets(line, sizeof(line), in)) {
fclose(in); fclose(out); remove(tmp); return SSQL_ERR_IO;
}
ncolumns = csv_parse_line(line, columns, SSQL_MAX_COLS);
if (ncolumns < 1) { fclose(in); fclose(out); remove(tmp); return SSQL_ERR_IO; }
int set_idx[SSQL_MAX_COLS];
if (!deleting) {
for (int i = 0; i < st->ncols; ++i) {
set_idx[i] = find_col(columns, ncolumns, st->cols[i]);
if (set_idx[i] < 0) { fclose(in); fclose(out); remove(tmp); return SSQL_ERR_NOCOL; }
for (int j = 0; j < i; ++j)
if (set_idx[i] == set_idx[j]) { fclose(in); fclose(out); remove(tmp); return SSQL_ERR_SYNTAX; }
}
}
int where_idx = -1;
if (st->have_where) {
where_idx = find_col(columns, ncolumns, st->where_col);
if (where_idx < 0) { fclose(in); fclose(out); remove(tmp); return SSQL_ERR_NOCOL; }
}
csv_write_row(out, columns, ncolumns);
while (fgets(line, sizeof(line), in)) {
char rowbuf[SSQL_MAX_FIELD * 8];
snprintf(rowbuf, sizeof(rowbuf), "%s", line);
char *fields[SSQL_MAX_COLS];
int nf = csv_parse_line(rowbuf, fields, SSQL_MAX_COLS);
if (nf == 0) continue;
if (nf != ncolumns) { fclose(in); fclose(out); remove(tmp); return SSQL_ERR_IO; }
int matches = !st->have_where ||
(where_idx < nf && strcmp(fields[where_idx], where_value) == 0);
if (deleting && matches) continue;
if (!deleting && matches)
for (int i = 0; i < st->ncols; ++i) fields[set_idx[i]] = (char *)set_values[i];
csv_write_row(out, fields, nf);
if (ferror(out)) { fclose(in); fclose(out); remove(tmp); return SSQL_ERR_IO; }
}
int input_error = ferror(in);
int output_error = ferror(out);
if (fclose(in) != 0) input_error = 1;
if (fclose(out) != 0) output_error = 1;
if (input_error || output_error) { remove(tmp); return SSQL_ERR_IO; }
ssql_status status = replace_table_file(tmp, path);
if (status != SSQL_OK) remove(tmp);
return status;
}
static void emit_table_name(FILE *out, const char *filename) {
size_t len = strlen(filename);
if (len <= 4 || strcmp(filename + len - 4, ".csv") != 0) return;
if (out) {
char base[SSQL_MAX_FIELD];
size_t blen = len - 4;
if (blen >= sizeof(base)) blen = sizeof(base) - 1;
memcpy(base, filename, blen);
base[blen] = '\0';
csv_write_field(out, base);
fputc('\n', out);
}
}
static ssql_status exec_show_tables(ssql_stmt *st, FILE *out) {
if (out) fputs("Tables_in_sleela_sql\n", out);
#ifdef _WIN32
{
char pattern[SSQL_MAX_PATH];
struct _finddata_t entry;
intptr_t handle;
snprintf(pattern, sizeof(pattern), "%s/*.csv", st->db->dir);
handle = _findfirst(pattern, &entry);
if (handle == -1L) return errno == ENOENT ? SSQL_OK : SSQL_ERR_IO;
do { emit_table_name(out, entry.name); } while (_findnext(handle, &entry) == 0);
_findclose(handle);
}
#else
{
DIR *d = opendir(st->db->dir);
struct dirent *e;
if (!d) return SSQL_ERR_IO;
while ((e = readdir(d)) != NULL) emit_table_name(out, e->d_name);
closedir(d);
}
#endif
return SSQL_OK;
}
static ssql_status exec_stmt(ssql_stmt *st, FILE *out) {
switch (st->op) {
case OP_CREATE: return exec_create(st);
case OP_ALTER: return exec_alter(st);
case OP_DROP: return exec_drop(st);
case OP_INSERT: return exec_insert(st);
case OP_UPDATE: return exec_rewrite(st, 0);
case OP_DELETE: return exec_rewrite(st, 1);
case OP_SELECT: return exec_select(st, out);
case OP_SHOW_TABLES: return exec_show_tables(st, out);
default: return SSQL_ERR_SYNTAX;
}
}
/* ===================================================================== *
* Public API
* ===================================================================== */
ssql_status ssql_open(ssql_db *db, const char *dir) {
struct stat st;
if (!db || !dir || !*dir) return SSQL_ERR_ARG;
if (strlen(dir) >= sizeof(db->dir)) return SSQL_ERR_ARG;
if (stat(dir, &st) != 0) {
if (errno != ENOENT || SSQL_MKDIR(dir) != 0) return SSQL_ERR_IO;
if (stat(dir, &st) != 0) return SSQL_ERR_IO;
}
#ifdef _WIN32
if ((st.st_mode & _S_IFMT) != _S_IFDIR) return SSQL_ERR_IO;
#else
if (!S_ISDIR(st.st_mode)) return SSQL_ERR_IO;
#endif
snprintf(db->dir, sizeof(db->dir), "%s", dir);
return SSQL_OK;
}
ssql_status ssql_prepare(ssql_db *db, const char *text,
ssql_dialect dialect, ssql_stmt **out_stmt) {
if (!db || !text || !out_stmt) return SSQL_ERR_ARG;
*out_stmt = NULL;
char *buf = str_dup(text);
if (!buf) return SSQL_ERR_OOM;
char *stmt = trim(buf);
size_t n = strlen(stmt);
while (n && (stmt[n - 1] == ';' || isspace((unsigned char)stmt[n - 1])))
stmt[--n] = '\0';
if (!*stmt) { free(buf); return SSQL_ERR_SYNTAX; }
if (dialect == SSQL_DIALECT_AUTO) dialect = sniff(stmt);
ssql_stmt *st = stmt_new(db);
if (!st) { free(buf); return SSQL_ERR_OOM; }
ssql_status s = (dialect == SSQL_DIALECT_SLEELA)
? compile_sleela(st, stmt)
: compile_sql(st, stmt);
if (s == SSQL_OK && st->op != OP_SHOW_TABLES && !valid_table_name(st->table)) s = SSQL_ERR_SYNTAX;
free(buf);
if (s != SSQL_OK) { ssql_finalize(st); return s; }
*out_stmt = st;
return SSQL_OK;
}
int ssql_param_count(const ssql_stmt *stmt) {
return stmt ? stmt->nparams : 0;
}
/* Point at the value slot for the given 1-based placeholder index, or NULL. */
static ssql_val *slot_for_param(ssql_stmt *stmt, int index) {
for (int i = 0; i < stmt->nvals; i++)
if (stmt->vals[i].param == index) return &stmt->vals[i];
if (stmt->have_where && stmt->where_val.param == index)
return &stmt->where_val;
return NULL;
}
ssql_status ssql_bind(ssql_stmt *stmt, int index, const char *value) {
if (!stmt || !value || index < 1 || index > stmt->nparams)
return SSQL_ERR_BIND;
ssql_val *v = slot_for_param(stmt, index);
if (!v) return SSQL_ERR_BIND;
char *copy = str_dup(value);
if (!copy) return SSQL_ERR_OOM;
if (v->lit) free(v->lit);
v->lit = copy;
return SSQL_OK;
}
void ssql_reset(ssql_stmt *stmt) {
if (!stmt) return;
for (int i = 0; i < stmt->nvals; i++)
if (stmt->vals[i].param != 0) val_free(&stmt->vals[i]);
if (stmt->have_where && stmt->where_val.param != 0)
val_free(&stmt->where_val);
}
ssql_status ssql_run(ssql_stmt *stmt, FILE *out) {
if (!stmt) return SSQL_ERR_ARG;
return exec_stmt(stmt, out);
}
ssql_status ssql_exec_dialect(ssql_db *db, const char *text,
ssql_dialect dialect, FILE *out) {
ssql_stmt *st = NULL;
ssql_status s = ssql_prepare(db, text, dialect, &st);
if (s != SSQL_OK) return s;
s = ssql_run(st, out);
ssql_finalize(st);
return s;
}
ssql_status ssql_exec(ssql_db *db, const char *text, FILE *out) {
return ssql_exec_dialect(db, text, SSQL_DIALECT_AUTO, out);
}
const char *ssql_strerror(ssql_status s) {
switch (s) {
case SSQL_OK: return "ok";
case SSQL_ERR_IO: return "I/O error";
case SSQL_ERR_SYNTAX: return "syntax error";
case SSQL_ERR_NOTABLE: return "no such table";
case SSQL_ERR_EXISTS: return "table already exists";
case SSQL_ERR_NOCOL: return "no such column";
case SSQL_ERR_ARITY: return "value count does not match column count";
case SSQL_ERR_ARG: return "bad argument";
case SSQL_ERR_BIND: return "unbound or out-of-range placeholder";
case SSQL_ERR_OOM: return "out of memory";
case SSQL_ERR_DUPCOL: return "column already exists";
default: return "unknown error";
}
}
const char *ssql_dialect_name(ssql_dialect d) {
switch (d) {
case SSQL_DIALECT_SQL: return "sql";
case SSQL_DIALECT_SLEELA: return "sleelasql";
default: return "auto";
}
}
/* ===================================================================== *
* Transactions (snapshot-based; see header for the honest guarantees)
* ===================================================================== */
/* The journal directory holding a transaction's table snapshot. */
static void journal_dir(const ssql_db *db, char *buf, size_t cap) {
snprintf(buf, cap, "%s/.ssql-txn", db->dir);
}
/* Byte-copy src -> dst. Returns SSQL_OK or SSQL_ERR_IO. */
static ssql_status copy_file(const char *src, const char *dst) {
FILE *in = fopen(src, "rb");
if (!in) return SSQL_ERR_IO;
FILE *out = fopen(dst, "wb");
if (!out) { fclose(in); return SSQL_ERR_IO; }
char buf[8192];
size_t n;
ssql_status rc = SSQL_OK;
while ((n = fread(buf, 1, sizeof buf, in)) > 0) {
if (fwrite(buf, 1, n, out) != n) { rc = SSQL_ERR_IO; break; }
}
if (ferror(in)) rc = SSQL_ERR_IO;
if (fclose(out) != 0) rc = SSQL_ERR_IO;
fclose(in);
return rc;
}
/* Does `name` end in ".csv"? */
static int is_csv_name(const char *name) {
size_t n = strlen(name);
return n > 4 && strcmp(name + n - 4, ".csv") == 0;
}
/*
* Walk the .csv files in `dir`, invoking fn(name, ctx) for each. Portable over
* the engine's existing POSIX/Win32 directory split. Returns SSQL_OK or
* SSQL_ERR_IO; a missing directory is treated as empty (SSQL_OK).
*/
typedef void (*csv_visitor)(const char *name, void *ctx);
static ssql_status for_each_csv(const char *dir, csv_visitor fn, void *ctx) {
#ifdef _WIN32
char pattern[SSQL_MAX_PATH];
struct _finddata_t entry;
intptr_t handle;
snprintf(pattern, sizeof(pattern), "%s/*.csv", dir);
handle = _findfirst(pattern, &entry);
if (handle == -1L) return errno == ENOENT ? SSQL_OK : SSQL_ERR_IO;
do { if (is_csv_name(entry.name)) fn(entry.name, ctx); } while (_findnext(handle, &entry) == 0);
_findclose(handle);
return SSQL_OK;
#else
DIR *d = opendir(dir);
struct dirent *e;
if (!d) return errno == ENOENT ? SSQL_OK : SSQL_ERR_IO;
while ((e = readdir(d)) != NULL)
if (is_csv_name(e->d_name)) fn(e->d_name, ctx);
closedir(d);
return SSQL_OK;
#endif
}
/* Context for snapshot/restore passes. */
typedef struct {
const ssql_db *db;
char jdir[SSQL_MAX_PATH];
ssql_status rc;
} txn_ctx;
static void snapshot_one(const char *name, void *vctx) {
txn_ctx *c = (txn_ctx *)vctx;
if (c->rc != SSQL_OK) return;
char src[SSQL_MAX_TXN_PATH], dst[SSQL_MAX_TXN_PATH];
snprintf(src, sizeof src, "%s/%s", c->db->dir, name);
snprintf(dst, sizeof dst, "%s/%s", c->jdir, name);
c->rc = copy_file(src, dst);
}
/* Collect .csv base names into a growable list (so we never modify a directory
* while a readdir/_findnext walk over it is still in progress). */
typedef struct { char **names; size_t n, cap; int oom; } name_list;
static void collect_name(const char *name, void *vctx) {
name_list *l = (name_list *)vctx;
if (l->oom) return;
if (l->n >= l->cap) {
size_t ncap = l->cap ? l->cap * 2 : 8;
char **p = (char **)realloc(l->names, ncap * sizeof *p);
if (!p) { l->oom = 1; return; }
l->names = p; l->cap = ncap;
}
char *dup = str_dup(name);
if (!dup) { l->oom = 1; return; }
l->names[l->n++] = dup;
}
static void name_list_free(name_list *l) {
for (size_t i = 0; i < l->n; ++i) free(l->names[i]);
free(l->names);
l->names = NULL; l->n = l->cap = 0;
}
static void restore_one(const char *name, void *vctx) {
txn_ctx *c = (txn_ctx *)vctx;
if (c->rc != SSQL_OK) return;
char src[SSQL_MAX_TXN_PATH], dst[SSQL_MAX_TXN_PATH];
snprintf(src, sizeof src, "%s/%s", c->jdir, name);
snprintf(dst, sizeof dst, "%s/%s", c->db->dir, name);
c->rc = copy_file(src, dst);
}
/* Remove every .csv in the journal dir, then the dir itself. */
static void journal_remove_one(const char *name, void *vctx) {
const char *jdir = (const char *)vctx;
char path[SSQL_MAX_TXN_PATH];
snprintf(path, sizeof path, "%s/%s", jdir, name);
remove(path);
}
static void clear_journal(const char *jdir) {
for_each_csv(jdir, journal_remove_one, (void *)jdir);
#ifdef _WIN32
_rmdir(jdir);
#else
rmdir(jdir);
#endif
}
int ssql_in_transaction(const ssql_db *db) {
if (!db) return 0;
char jdir[SSQL_MAX_PATH];
struct stat st;
journal_dir(db, jdir, sizeof jdir);
return (stat(jdir, &st) == 0) ? 1 : 0;
}
ssql_status ssql_begin(ssql_db *db) {
if (!db) return SSQL_ERR_ARG;
if (ssql_in_transaction(db)) return SSQL_ERR_ARG; /* already in a txn */
char jdir[SSQL_MAX_PATH];
journal_dir(db, jdir, sizeof jdir);
if (SSQL_MKDIR(jdir) != 0) return SSQL_ERR_IO;
txn_ctx c;
c.db = db;
c.rc = SSQL_OK;
snprintf(c.jdir, sizeof c.jdir, "%s", jdir);
ssql_status walk = for_each_csv(db->dir, snapshot_one, &c);
if (walk != SSQL_OK || c.rc != SSQL_OK) {
clear_journal(jdir);
return SSQL_ERR_IO;
}
return SSQL_OK;
}
ssql_status ssql_commit(ssql_db *db) {
if (!db) return SSQL_ERR_ARG;
if (!ssql_in_transaction(db)) return SSQL_ERR_ARG; /* no open txn */
char jdir[SSQL_MAX_PATH];
journal_dir(db, jdir, sizeof jdir);
/* Commit = accept current on-disk state; just discard the snapshot. */
clear_journal(jdir);
return SSQL_OK;
}
ssql_status ssql_rollback(ssql_db *db) {
if (!db) return SSQL_ERR_ARG;
if (!ssql_in_transaction(db)) return SSQL_ERR_ARG; /* no open txn */
char jdir[SSQL_MAX_PATH];
journal_dir(db, jdir, sizeof jdir);
txn_ctx c;
c.db = db;
c.rc = SSQL_OK;
snprintf(c.jdir, sizeof c.jdir, "%s", jdir);
/* 1) Collect current table names, then delete them (iteration-safe: we do
* not remove files while still walking the directory). This undoes any
* tables CREATEd during the transaction; snapshot tables are rewritten
* by the restore pass below. */
name_list cur = {0};
for_each_csv(db->dir, collect_name, &cur);
if (cur.oom) { name_list_free(&cur); return SSQL_ERR_OOM; }
for (size_t i = 0; i < cur.n; ++i) {
char path[SSQL_MAX_TXN_PATH];
snprintf(path, sizeof path, "%s/%s", db->dir, cur.names[i]);
remove(path);
}
name_list_free(&cur);
/* 2) Restore every table captured at begin (undoes UPDATE/DELETE/DROP). */
ssql_status walk = for_each_csv(jdir, restore_one, &c);
if (walk != SSQL_OK || c.rc != SSQL_OK) {
/* Leave the journal in place for manual recovery on a restore failure. */
return SSQL_ERR_IO;
}
clear_journal(jdir);
return SSQL_OK;
}