if (db) {

async::sqlite3_close(db);

}

CleanupDB();

CallbackCtx* ctx = static_cast<CallbackCtx*>(ptr);

ctx->rowCount++;

// Assumption: We are selecting specific columns, verify argv[0] exists

if (argc > 0 && argv[0]) {

ctx->capturedNames.push_back(std::string(argv[0]));

}

else {

ctx->capturedNames.push_back("NULL");

}

return 0; // Return 0 to continue

{

sqlite3* db = SetupDB();

int rc = 0;

char* errMsg = nullptr;

// 1. Create Table

const char* sqlCreate = "CREATE TABLE users (id INT, name TEXT);";

rc = async::sqlite3_exec(db, sqlCreate, nullptr, nullptr, &errMsg);

if (rc != SQLITE_OK) {

std::cerr << "Create Error: " << (errMsg ? errMsg : "Unknown") << std::endl;

async::sqlite3_free(errMsg);

}

ASSERT_TRUE(rc == SQLITE_OK);

// 2. Insert Data

const char* sqlInsert = "INSERT INTO users VALUES (1, 'Alice'); "

"INSERT INTO users VALUES (2, 'Bob');";

rc = async::sqlite3_exec(db, sqlInsert, nullptr, nullptr, &errMsg);

if (rc != SQLITE_OK) {

std::cerr << "Insert Error: " << (errMsg ? errMsg : "Unknown") << std::endl;

async::sqlite3_free(errMsg);

}

ASSERT_TRUE(rc == SQLITE_OK);

TearDownDB(db);

{

sqlite3* db = SetupDB();

int rc = 0;

// Seed Data

const char* seedSql = "CREATE TABLE items (name TEXT); "

"INSERT INTO items VALUES ('ItemA'); "

"INSERT INTO items VALUES ('ItemB'); "

"INSERT INTO items VALUES ('ItemC');";

async::sqlite3_exec(db, seedSql, nullptr, nullptr, nullptr);

// Prepare Context on Main Thread Stack

CallbackCtx ctx;

// Execute Select

// NOTE: We pass the address of 'ctx'. The pointer is marshaled to the

// worker thread. The worker thread writes to 'ctx' memory.

// This is safe because AsyncInvoke waits for completion before returning.

const char* selectSql = "SELECT name FROM items ORDER BY name ASC;";

rc = async::sqlite3_exec(db, selectSql, &TestCallback, &ctx, nullptr);

// Verify Results

ASSERT_TRUE(rc == SQLITE_OK);

ASSERT_TRUE(ctx.rowCount == 3);

ASSERT_TRUE(ctx.capturedNames.size() == 3);

ASSERT_TRUE(ctx.capturedNames[0] == "ItemA");

ASSERT_TRUE(ctx.capturedNames[1] == "ItemB");

ASSERT_TRUE(ctx.capturedNames[2] == "ItemC");

TearDownDB(db);

{

sqlite3* db = SetupDB();

// Create a table with multiple rows

const char* seedSql = "CREATE TABLE nums (val INT); "

"INSERT INTO nums VALUES (1); "

"INSERT INTO nums VALUES (2); "

"INSERT INTO nums VALUES (3);";

async::sqlite3_exec(db, seedSql, nullptr, nullptr, nullptr);

// This callback returns 1, which should stop SQLite

int rc = async::sqlite3_exec(db, "SELECT val FROM nums;", &AbortCallback, nullptr, nullptr);

// SQLite should return SQLITE_ABORT

ASSERT_TRUE(rc == SQLITE_ABORT);

TearDownDB(db);

{

sqlite3* db = SetupDB();

char* zErrMsg = nullptr;

// Execute invalid SQL (Syntax error)

const char* badSql = "SELECT * FROM non_existent_table_xyz";

int rc = async::sqlite3_exec(db, badSql, nullptr, nullptr, &zErrMsg);

// 1. Verify Error Code

ASSERT_TRUE(rc != SQLITE_OK);

// 2. Verify Error Message was populated

// Since &zErrMsg (char**) was passed to the worker thread, and SQLite allocated

// the string, the pointer value in zErrMsg should now point to that string.

ASSERT_TRUE(zErrMsg != nullptr);

std::string errStr(zErrMsg);

// Simple check to ensure it contains relevant info

ASSERT_TRUE(errStr.find("no such table") != std::string::npos);

// 3. Free the error string using the Async API

// (Crucial: Memory allocated by SQLite on worker thread should be freed via SQLite API)

async::sqlite3_free(zErrMsg);

TearDownDB(db);

{

std::cout << "Running SQLite Direct Exec Tests..." << std::endl;

CleanupDB(); // Pre-flight cleanup

Test_Exec_CreateAndInsert();

Test_Exec_SelectCallback();

Test_Exec_Abort();

Test_Exec_Error();

std::cout << "SQLite Direct Exec Tests Passed!" << std::endl;

}