#include "wren.h"
#include <sqlite3.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#ifdef _WIN32
#include <windows.h>
typedef HANDLE thread_t;
typedef CRITICAL_SECTION mutex_t;
typedef CONDITION_VARIABLE cond_t;
#define GET_THREAD_ID() GetCurrentThreadId()
#else
#include <pthread.h>
typedef pthread_t thread_t;
typedef pthread_mutex_t mutex_t;
typedef pthread_cond_t cond_t;
#define GET_THREAD_ID() pthread_self()
#endif
#define TRACE() printf("[TRACE] %s:%d\n", __FUNCTION__, __LINE__)
// --- Data Structures ---
typedef enum {
DB_OP_OPEN,
DB_OP_EXEC,
DB_OP_QUERY,
DB_OP_CLOSE
} DBOp;
typedef struct {
sqlite3* db;
} DatabaseData;
// C-side representation of query results to pass from worker to main thread.
typedef struct DbValue {
int type;
union {
double num;
struct {
char* text;
int length;
} str;
} as;
} DbValue;
typedef struct DbRow {
char** columns;
DbValue* values;
int count;
struct DbRow* next;
} DbRow;
typedef struct DbContext {
WrenVM* vm;
DBOp operation;
WrenHandle* callback;
WrenHandle* dbHandle;
char* path;
sqlite3* newDb;
char* sql;
sqlite3* db;
bool success;
char* errorMessage;
DbRow* resultRows;
struct DbContext* next;
} DbContext;
// --- Thread-Safe Queue ---
typedef struct {
DbContext *head, *tail;
mutex_t mutex;
cond_t cond;
} DbThreadSafeQueue;
void db_queue_init(DbThreadSafeQueue* q) {
TRACE();
q->head = q->tail = NULL;
#ifdef _WIN32
InitializeCriticalSection(&q->mutex);
InitializeConditionVariable(&q->cond);
#else
pthread_mutex_init(&q->mutex, NULL);
pthread_cond_init(&q->cond, NULL);
#endif
TRACE();
}
void db_queue_destroy(DbThreadSafeQueue* q) {
TRACE();
#ifdef _WIN32
DeleteCriticalSection(&q->mutex);
#else
pthread_mutex_destroy(&q->mutex);
pthread_cond_destroy(&q->cond);
#endif
TRACE();
}
void db_queue_push(DbThreadSafeQueue* q, DbContext* context) {
TRACE();
#ifdef _WIN32
EnterCriticalSection(&q->mutex);
#else
pthread_mutex_lock(&q->mutex);
#endif
TRACE();
if(context) context->next = NULL;
TRACE();
if (q->tail) q->tail->next = context;
else q->head = context;
TRACE();
q->tail = context;
TRACE();
#ifdef _WIN32
WakeConditionVariable(&q->cond);
LeaveCriticalSection(&q->mutex);
#else
pthread_cond_signal(&q->cond);
pthread_mutex_unlock(&q->mutex);
#endif
TRACE();
}
DbContext* db_queue_pop(DbThreadSafeQueue* q) {
TRACE();
#ifdef _WIN32
EnterCriticalSection(&q->mutex);
while (q->head == NULL) {
SleepConditionVariableCS(&q->cond, &q->mutex, INFINITE);
}
#else
pthread_mutex_lock(&q->mutex);
while (q->head == NULL) {
pthread_cond_wait(&q->cond, &q->mutex);
}
#endif
TRACE();
DbContext* context = q->head;
TRACE();
q->head = q->head->next;
TRACE();
if (q->head == NULL) q->tail = NULL;
TRACE();
#ifdef _WIN32
LeaveCriticalSection(&q->mutex);
#else
pthread_mutex_unlock(&q->mutex);
#endif
TRACE();
return context;
}
bool db_queue_empty(DbThreadSafeQueue* q) {
TRACE();
bool empty;
#ifdef _WIN32
EnterCriticalSection(&q->mutex);
empty = (q->head == NULL);
LeaveCriticalSection(&q->mutex);
#else
pthread_mutex_lock(&q->mutex);
empty = (q->head == NULL);
pthread_mutex_unlock(&q->mutex);
#endif
TRACE();
return empty;
}
// --- Async DB Manager ---
typedef struct {
WrenVM* vm;
volatile bool running;
thread_t threads[2];
DbThreadSafeQueue requestQueue;
DbThreadSafeQueue completionQueue;
} AsyncDbManager;
static AsyncDbManager* dbManager = NULL;
void free_db_result_rows(DbRow* rows) {
TRACE();
while (rows) {
TRACE();
DbRow* next = rows->next;
if (rows->columns) {
TRACE();
for (int i = 0; i < rows->count; i++) {
free(rows->columns[i]);
}
free(rows->columns);
}
if (rows->values) {
TRACE();
for (int i = 0; i < rows->count; i++) {
if (rows->values[i].type == SQLITE_TEXT || rows->values[i].type == SQLITE_BLOB) {
free(rows->values[i].as.str.text);
}
}
free(rows->values);
}
free(rows);
rows = next;
}
TRACE();
}
void free_db_context(DbContext* context) {
TRACE();
if (context == NULL) { TRACE(); return; }
TRACE();
free(context->path);
TRACE();
free(context->sql);
TRACE();
free(context->errorMessage);
TRACE();
if (context->dbHandle) wrenReleaseHandle(context->vm, context->dbHandle);
TRACE();
if (context->callback) wrenReleaseHandle(context->vm, context->callback);
TRACE();
if (context->resultRows) free_db_result_rows(context->resultRows);
TRACE();
free(context);
TRACE();
}
static void set_context_error(DbContext* context, const char* message) {
TRACE();
if (context == NULL) { TRACE(); return; }
TRACE();
context->success = false;
TRACE();
if (context->errorMessage) {
free(context->errorMessage);
}
TRACE();
if (message) {
context->errorMessage = strdup(message);
} else {
context->errorMessage = strdup("An unknown database error occurred (possibly out of memory).");
}
TRACE();
}
#ifdef _WIN32
DWORD WINAPI dbWorkerThread(LPVOID arg);
#else
void* dbWorkerThread(void* arg);
#endif
void dbManager_create(WrenVM* vm) {
TRACE();
if (dbManager != NULL) { TRACE(); return; }
TRACE();
dbManager = (AsyncDbManager*)malloc(sizeof(AsyncDbManager));
TRACE();
if (dbManager == NULL) { TRACE(); return; }
TRACE();
dbManager->vm = vm;
TRACE();
dbManager->running = true;
TRACE();
db_queue_init(&dbManager->requestQueue);
TRACE();
db_queue_init(&dbManager->completionQueue);
TRACE();
for (int i = 0; i < 2; ++i) {
#ifdef _WIN32
dbManager->threads[i] = CreateThread(NULL, 0, dbWorkerThread, dbManager, 0, NULL);
#else
pthread_create(&dbManager->threads[i], NULL, dbWorkerThread, dbManager);
#endif
}
TRACE();
}
void dbManager_destroy() {
TRACE();
if (!dbManager) { TRACE(); return; }
TRACE();
dbManager->running = false;
TRACE();
for (int i = 0; i < 2; ++i) {
db_queue_push(&dbManager->requestQueue, NULL);
}
TRACE();
for (int i = 0; i < 2; ++i) {
#ifdef _WIN32
WaitForSingleObject(dbManager->threads[i], INFINITE);
CloseHandle(dbManager->threads[i]);
#else
pthread_join(dbManager->threads[i], NULL);
#endif
}
TRACE();
while(!db_queue_empty(&dbManager->requestQueue)) free_db_context(db_queue_pop(&dbManager->requestQueue));
TRACE();
while(!db_queue_empty(&dbManager->completionQueue)) free_db_context(db_queue_pop(&dbManager->completionQueue));
TRACE();
db_queue_destroy(&dbManager->requestQueue);
TRACE();
db_queue_destroy(&dbManager->completionQueue);
TRACE();
free(dbManager);
TRACE();
dbManager = NULL;
TRACE();
}
void dbManager_processCompletions() {
TRACE();
if (!dbManager || !dbManager->vm || db_queue_empty(&dbManager->completionQueue)) { TRACE(); return; }
TRACE();
WrenHandle* callHandle = wrenMakeCallHandle(dbManager->vm, "call(_,_)");
TRACE();
if (callHandle == NULL) { TRACE(); return; }
TRACE();
while (!db_queue_empty(&dbManager->completionQueue)) {
TRACE();
DbContext* context = db_queue_pop(&dbManager->completionQueue);
TRACE();
if (context == NULL) { TRACE(); continue; }
TRACE();
if (context->success && context->dbHandle) {
TRACE();
wrenEnsureSlots(dbManager->vm, 1);
TRACE();
wrenSetSlotHandle(dbManager->vm, 0, context->dbHandle);
TRACE();
DatabaseData* dbData = (DatabaseData*)wrenGetSlotForeign(dbManager->vm, 0);
TRACE();
if (dbData) {
TRACE();
if (context->operation == DB_OP_OPEN) {
dbData->db = context->newDb;
} else if (context->operation == DB_OP_CLOSE) {
dbData->db = NULL;
}
}
}
TRACE();
if (context->callback == NULL) {
TRACE();
free_db_context(context);
continue;
}
TRACE();
wrenEnsureSlots(dbManager->vm, 3);
TRACE();
wrenSetSlotHandle(dbManager->vm, 0, context->callback);
TRACE();
if (context->success) {
TRACE();
wrenSetSlotNull(dbManager->vm, 1); // error
TRACE();
if (context->resultRows) {
TRACE();
wrenSetSlotNewList(dbManager->vm, 2);
DbRow* row = context->resultRows;
while(row) {
wrenSetSlotNewMap(dbManager->vm, 1);
for (int i = 0; i < row->count; i++) {
wrenSetSlotString(dbManager->vm, 0, row->columns[i]); // key
DbValue* val = &row->values[i];
switch (val->type) {
case SQLITE_INTEGER: case SQLITE_FLOAT:
wrenSetSlotDouble(dbManager->vm, 1, val->as.num); break;
case SQLITE_TEXT:
wrenSetSlotBytes(dbManager->vm, 1, val->as.str.text, val->as.str.length); break;
case SQLITE_BLOB:
wrenSetSlotBytes(dbManager->vm, 1, val->as.str.text, val->as.str.length); break;
case SQLITE_NULL:
wrenSetSlotNull(dbManager->vm, 1); break;
}
wrenSetMapValue(dbManager->vm, 1, 0, 1);
}
wrenInsertInList(dbManager->vm, 2, -1, 1);
row = row->next;
}
} else {
TRACE();
wrenSetSlotNull(dbManager->vm, 2);
}
} else {
TRACE();
wrenSetSlotString(dbManager->vm, 1, context->errorMessage ? context->errorMessage : "Unknown error.");
TRACE();
wrenSetSlotNull(dbManager->vm, 2);
}
TRACE();
wrenCall(dbManager->vm, callHandle);
TRACE();
free_db_context(context);
}
TRACE();
wrenReleaseHandle(dbManager->vm, callHandle);
TRACE();
}
// --- Worker Thread ---
#ifdef _WIN32
DWORD WINAPI dbWorkerThread(LPVOID arg) {
#else
void* dbWorkerThread(void* arg) {
#endif
TRACE();
AsyncDbManager* manager = (AsyncDbManager*)arg;
TRACE();
while (manager->running) {
TRACE();
DbContext* context = db_queue_pop(&manager->requestQueue);
TRACE();
if (!context || !manager->running) {
TRACE();
if (context) free_db_context(context);
break;
}
TRACE();
switch (context->operation) {
case DB_OP_OPEN: {
TRACE();
int rc = sqlite3_open_v2(context->path, &context->newDb,
SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX,
NULL);
TRACE();
if (rc != SQLITE_OK) {
TRACE();
set_context_error(context, sqlite3_errmsg(context->newDb));
TRACE();
sqlite3_close(context->newDb);
TRACE();
context->newDb = NULL;
} else {
TRACE();
context->success = true;
}
break;
}
case DB_OP_EXEC: {
TRACE();
if (!context->db) {
TRACE();
set_context_error(context, "Database is not open.");
break;
}
TRACE();
char* err = NULL;
TRACE();
int rc = sqlite3_exec(context->db, context->sql, 0, 0, &err);
TRACE();
if (rc != SQLITE_OK) {
TRACE();
set_context_error(context, err);
TRACE();
sqlite3_free(err);
} else {
TRACE();
context->success = true;
}
break;
}
case DB_OP_QUERY: {
TRACE();
if (!context->db) {
TRACE();
set_context_error(context, "Database is not open.");
break;
}
TRACE();
sqlite3_stmt* stmt;
TRACE();
int rc = sqlite3_prepare_v2(context->db, context->sql, -1, &stmt, 0);
TRACE();
if (rc != SQLITE_OK) {
TRACE();
set_context_error(context, sqlite3_errmsg(context->db));
break;
}
TRACE();
int colCount = sqlite3_column_count(stmt);
DbRow* head = NULL;
DbRow* tail = NULL;
bool oom = false;
TRACE();
while ((rc = sqlite3_step(stmt)) == SQLITE_ROW) {
TRACE();
DbRow* row = (DbRow*)calloc(1, sizeof(DbRow));
if (row == NULL) { oom = true; break; }
row->count = colCount;
row->columns = (char**)malloc(sizeof(char*) * colCount);
row->values = (DbValue*)malloc(sizeof(DbValue) * colCount);
if (row->columns == NULL || row->values == NULL) {
free(row->columns); free(row->values); free(row);
oom = true; break;
}
for (int i = 0; i < colCount; i++) {
const char* colName = sqlite3_column_name(stmt, i);
row->columns[i] = colName ? strdup(colName) : strdup("");
if (row->columns[i] == NULL) {
for (int j = 0; j < i; j++) free(row->columns[j]);
free(row->columns); free(row->values); free(row);
oom = true; goto query_loop_end;
}
DbValue* val = &row->values[i];
val->type = sqlite3_column_type(stmt, i);
switch (val->type) {
case SQLITE_INTEGER: case SQLITE_FLOAT:
val->as.num = sqlite3_column_double(stmt, i);
break;
case SQLITE_TEXT: case SQLITE_BLOB: {
const void* blob = sqlite3_column_blob(stmt, i);
int len = sqlite3_column_bytes(stmt, i);
val->as.str.text = (char*)malloc(len);
if (val->as.str.text == NULL) {
for (int j = 0; j <= i; j++) free(row->columns[j]);
free(row->columns); free(row->values); free(row);
oom = true; goto query_loop_end;
}
memcpy(val->as.str.text, blob, len);
val->as.str.length = len;
break;
}
case SQLITE_NULL: break;
}
}
if (head == NULL) head = tail = row;
else { tail->next = row; tail = row; }
}
query_loop_end:;
TRACE();
if (oom) {
set_context_error(context, "Memory allocation failed during query.");
free_db_result_rows(head);
} else if (rc != SQLITE_DONE) {
set_context_error(context, sqlite3_errmsg(context->db));
free_db_result_rows(head);
} else {
context->success = true;
context->resultRows = head;
}
TRACE();
sqlite3_finalize(stmt);
break;
}
case DB_OP_CLOSE: {
TRACE();
if (context->db) {
sqlite3_close(context->db);
}
TRACE();
context->success = true;
break;
}
}
TRACE();
db_queue_push(&manager->completionQueue, context);
}
TRACE();
return 0;
}
// --- Wren FFI ---
void dbAllocate(WrenVM* vm) {
TRACE();
DatabaseData* data = (DatabaseData*)wrenSetSlotNewForeign(vm, 0, 0, sizeof(DatabaseData));
if (data) data->db = NULL;
TRACE();
}
void dbFinalize(void* data) {
TRACE();
DatabaseData* dbData = (DatabaseData*)data;
if (dbData && dbData->db) {
sqlite3_close(dbData->db);
}
TRACE();
}
static void ensureDbManager(WrenVM* vm)
{
if (!dbManager) dbManager_create(vm);
}
static void create_db_context(WrenVM* vm,
DBOp op,
int sqlSlot,
int cbSlot)
{
TRACE();
DbContext* context = calloc(1, sizeof(*context));
if (!context)
{
wrenSetSlotString(vm, 0, "Out of memory creating DbContext.");
wrenAbortFiber(vm, 0);
return;
}
context->vm = vm;
context->operation = op;
/* ------------------------------------------------------------------ */
/* 1. Grab the SQL bytes *first* (before any API call that might GC) */
/* ------------------------------------------------------------------ */
if (sqlSlot != -1)
{
if (wrenGetSlotType(vm, sqlSlot) != WREN_TYPE_STRING)
{
wrenSetSlotString(vm, 0, "SQL argument must be a string.");
wrenAbortFiber(vm, 0);
free(context);
return;
}
int len = 0;
const char* bytes = wrenGetSlotBytes(vm, sqlSlot, &len);
context->sql = malloc((size_t)len + 1);
if (!context->sql)
{
wrenSetSlotString(vm, 0, "Out of memory copying SQL string.");
wrenAbortFiber(vm, 0);
free(context);
return;
}
memcpy(context->sql, bytes, (size_t)len);
context->sql[len] = '\0'; /* NUL‑
}
/* -------------------------------------------------------------- */
/* 2. Now take the handles –
/* -------------------------------------------------------------- */
context->dbHandle = wrenGetSlotHandle(vm, 0);
context->callback = wrenGetSlotHandle(vm, cbSlot);
/* -------------------------------------------------------------- */
/* 3. Stash live DB pointer and queue the request */
/* -------------------------------------------------------------- */
DatabaseData* dbData = wrenGetSlotForeign(vm, 0);
if (!dbData)
{
set_context_error(context, "Internal error: bad Database object.");
db_queue_push(&dbManager->requestQueue, context);
return;
}
context->db = dbData->db;
db_queue_push(&dbManager->requestQueue, context);
TRACE();
}
void dbOpen(WrenVM* vm) {
ensureDbManager(vm);
TRACE();
DbContext* context = (DbContext*)calloc(1, sizeof(DbContext));
if (context == NULL) {
wrenSetSlotString(vm, 0, "Failed to allocate memory for database operation.");
wrenAbortFiber(vm, 0);
return;
}
context->vm = vm;
context->operation = DB_OP_OPEN;
const char* path_str = wrenGetSlotString(vm, 1);
if (path_str) context->path = strdup(path_str);
if (context->path == NULL) {
free(context);
wrenSetSlotString(vm, 0, "Failed to allocate memory for database path.");
wrenAbortFiber(vm, 0);
return;
}
context->dbHandle = wrenGetSlotHandle(vm, 0);
context->callback = wrenGetSlotHandle(vm, 2);
db_queue_push(&dbManager->requestQueue, context);
TRACE();
}
void dbExec(WrenVM* vm) {
ensureDbManager(vm);
TRACE();
create_db_context(vm, DB_OP_EXEC, 1, 2);
TRACE();
}
void dbQuery(WrenVM* vm) {
ensureDbManager(vm);
TRACE();
TRACE();
create_db_context(vm, DB_OP_QUERY, 1, 2);
TRACE();
}
void dbClose(WrenVM* vm) {
ensureDbManager(vm);
TRACE();
TRACE();
create_db_context(vm, DB_OP_CLOSE, -1, 1);
TRACE();
}
WrenForeignMethodFn bindSqliteForeignMethod(WrenVM* vm, const char* module, const char* className, bool isStatic, const char* signature) {
TRACE();
if (strcmp(module, "sqlite") != 0) return NULL;
if (strcmp(className, "Database") == 0 && !isStatic) {
if (strcmp(signature, "open_(_,_)") == 0) return dbOpen;
if (strcmp(signature, "exec_(_,_)") == 0) return dbExec;
if (strcmp(signature, "query_(_,_)") == 0) return dbQuery;
if (strcmp(signature, "close_(_)") == 0) return dbClose;
}
return NULL;
}
WrenForeignClassMethods bindSqliteForeignClass(WrenVM* vm, const char* module, const char* className) {
TRACE();
if (strcmp(module, "sqlite") == 0 && strcmp(className, "Database") == 0) {
WrenForeignClassMethods methods = {dbAllocate, dbFinalize};
return methods;
}
WrenForeignClassMethods methods = {0, 0};
return methods;
}