Napi::HandleScope scope(env);

// declare napi_default_method here as it is only available in Node v14.12.0+

auto napi_default_method = static_cast<napi_property_attributes>(napi_writable | napi_configurable);

auto t = DefineClass(env, "Statement", {

InstanceMethod("bind", &Statement::Bind, napi_default_method),

InstanceMethod("get", &Statement::Get, napi_default_method),

InstanceMethod("run", &Statement::Run, napi_default_method),

InstanceMethod("all", &Statement::All, napi_default_method),

InstanceMethod("each", &Statement::Each, napi_default_method),

InstanceMethod("reset", &Statement::Reset, napi_default_method),

InstanceMethod("finalize", &Statement::Finalize_, napi_default_method),

});

exports.Set("Statement", t);

return exports;

if (strncmp(object_type, "Date", 4) == 0) {

return source.InstanceOf(source.Env().Global().Get("Date").As<Function>());

} else if (strncmp(object_type, "RegExp", 6) == 0) {

return source.InstanceOf(source.Env().Global().Get("RegExp").As<Function>());

}

return false;

if (finalized && !queue.empty()) {

return CleanQueue();

}

while (prepared && !locked && !queue.empty()) {

auto call = std::unique_ptr<Call>(queue.front());

queue.pop();

call->callback(call->baton);

}

if (finalized) {

queue.emplace(new Call(callback, baton));

CleanQueue();

}

else if (!prepared || locked) {

queue.emplace(new Call(callback, baton));

}

else {

callback(baton);

}

Statement* stmt = baton->stmt;

auto env = stmt->Env();

Napi::HandleScope scope(env);

// Fail hard on logic errors.

assert(stmt->status != 0);

EXCEPTION(Napi::String::New(env, stmt->message.c_str()), stmt->status, exception);

Napi::Function cb = baton->callback.Value();

if (IS_FUNCTION(cb)) {

Napi::Value argv[] = { exception };

TRY_CATCH_CALL(stmt->Value(), cb, 1, argv);

}

else {

Napi::Value argv[] = { Napi::String::New(env, "error"), exception };

EMIT_EVENT(stmt->Value(), 2, argv);

}

auto env = info.Env();

int length = info.Length();

if (length <= 0 || !Database::HasInstance(info[0])) {

Napi::TypeError::New(env, "Database object expected").ThrowAsJavaScriptException();

return;

}

else if (length <= 1 || !info[1].IsString()) {

Napi::TypeError::New(env, "SQL query expected").ThrowAsJavaScriptException();

return;

}

else if (length > 2 && !info[2].IsUndefined() && !info[2].IsFunction()) {

Napi::TypeError::New(env, "Callback expected").ThrowAsJavaScriptException();

return;

}

Database* db = Napi::ObjectWrap<Database>::Unwrap(info[0].As<Napi::Object>());

auto sql = info[1].As<Napi::String>();

info.This().As<Napi::Object>().DefineProperty(Napi::PropertyDescriptor::Value("sql", sql, napi_default));

init(db);

Statement* stmt = this;

auto* baton = new PrepareBaton(db, info[2].As<Napi::Function>(), stmt);

baton->sql = std::string(sql.As<Napi::String>().Utf8Value().c_str());

db->Schedule(Work_BeginPrepare, baton);

assert(baton->db->open);

baton->db->pending++;

auto env = baton->db->Env();

int UNUSED(status) = napi_create_async_work(

env, NULL, Napi::String::New(env, "sqlite3.Statement.Prepare"),

Work_Prepare, Work_AfterPrepare, baton, &baton->request

);

assert(status == 0);

napi_queue_async_work(env, baton->request);

STATEMENT_INIT(PrepareBaton);

// In case preparing fails, we use a mutex to make sure we get the associated

// error message.

STATEMENT_MUTEX(mtx);

sqlite3_mutex_enter(mtx);

stmt->status = sqlite3_prepare_v2(

baton->db->_handle,

baton->sql.c_str(),

baton->sql.size(),

&stmt->_handle,

NULL

);

if (stmt->status != SQLITE_OK) {

stmt->message = std::string(sqlite3_errmsg(baton->db->_handle));

stmt->_handle = NULL;

}

sqlite3_mutex_leave(mtx);

std::unique_ptr<PrepareBaton> baton(static_cast<PrepareBaton*>(data));

auto* stmt = baton->stmt;

auto env = stmt->Env();

Napi::HandleScope scope(env);

if (stmt->status != SQLITE_OK) {

Error(baton.get());

stmt->Finalize_();

}

else {

stmt->prepared = true;

if (!baton->callback.IsEmpty() && baton->callback.Value().IsFunction()) {

Napi::Function cb = baton->callback.Value();

Napi::Value argv[] = { env.Null() };

TRY_CATCH_CALL(stmt->Value(), cb, 1, argv);

}

}

STATEMENT_END();

if (source.IsString()) {

std::string val = source.As<Napi::String>().Utf8Value();

return std::make_unique<Values::Text>(pos, val.length(), val.c_str());

}

else if (OtherInstanceOf(source.As<Object>(), "RegExp")) {

std::string val = source.ToString().Utf8Value();

return std::make_unique<Values::Text>(pos, val.length(), val.c_str());

}

else if (source.IsNumber()) {

if (OtherIsInt(source.As<Napi::Number>())) {

return std::make_unique<Values::Integer>(pos, source.As<Napi::Number>().Int32Value());

} else {

return std::make_unique<Values::Float>(pos, source.As<Napi::Number>().DoubleValue());

}

}

else if (source.IsBoolean()) {

return std::make_unique<Values::Integer>(pos, source.As<Napi::Boolean>().Value() ? 1 : 0);

}

else if (source.IsNull()) {

return std::make_unique<Values::Null>(pos);

}

else if (source.IsBuffer()) {

Napi::Buffer<char> buffer = source.As<Napi::Buffer<char>>();

return std::make_unique<Values::Blob>(pos, buffer.Length(), buffer.Data());

}

else if (OtherInstanceOf(source.As<Object>(), "Date")) {

return std::make_unique<Values::Float>(pos, source.ToNumber().DoubleValue());

}

else if (source.IsObject()) {

auto napiVal = Napi::String::New(source.Env(), "[object Object]");

// Check whether toString returned a value that is not undefined.

if(napiVal.Type() == 0) {

return NULL;

}

std::string val = napiVal.Utf8Value();

return std::make_unique<Values::Text>(pos, val.length(), val.c_str());

}

else {

return NULL;

}

if (parameters.empty()) {

return true;

}

sqlite3_reset(_handle);

sqlite3_clear_bindings(_handle);

for (auto& field : parameters) {

if (field == NULL)

continue;

unsigned int pos;

if (field->index > 0) {

pos = field->index;

}

else {

pos = sqlite3_bind_parameter_index(_handle, field->name.c_str());

}

switch (field->type) {

case SQLITE_INTEGER: {

status = sqlite3_bind_int(_handle, pos,

(static_cast<Values::Integer*>(field.get()))->value);

} break;

case SQLITE_FLOAT: {

status = sqlite3_bind_double(_handle, pos,

(static_cast<Values::Float*>(field.get()))->value);

} break;

case SQLITE_TEXT: {

status = sqlite3_bind_text(_handle, pos,

(static_cast<Values::Text*>(field.get()))->value.c_str(),

(static_cast<Values::Text*>(field.get()))->value.size(), SQLITE_TRANSIENT);

} break;

case SQLITE_BLOB: {

status = sqlite3_bind_blob(_handle, pos,

(static_cast<Values::Blob*>(field.get()))->value,

(static_cast<Values::Blob*>(field.get()))->length, SQLITE_TRANSIENT);

} break;

case SQLITE_NULL: {

status = sqlite3_bind_null(_handle, pos);

} break;

}

if (status != SQLITE_OK) {

message = std::string(sqlite3_errmsg(db->_handle));

return false;

}

}

return true;

auto env = info.Env();

Statement* stmt = this;

auto baton = stmt->Bind<Baton>(info);

if (baton == NULL) {

Napi::TypeError::New(env, "Data type is not supported").ThrowAsJavaScriptException();

return env.Null();

}

else {

stmt->Schedule(Work_BeginBind, baton);

return info.This();

}

STATEMENT_INIT(Baton);

STATEMENT_MUTEX(mtx);

sqlite3_mutex_enter(mtx);

stmt->Bind(baton->parameters);

sqlite3_mutex_leave(mtx);

std::unique_ptr<Baton> baton(static_cast<Baton*>(data));

auto* stmt = baton->stmt;

auto env = stmt->Env();

Napi::HandleScope scope(env);

if (stmt->status != SQLITE_OK) {

Error(baton.get());

}

else {

// Fire callbacks.

Napi::Function cb = baton->callback.Value();

if (IS_FUNCTION(cb)) {

Napi::Value argv[] = { env.Null() };

TRY_CATCH_CALL(stmt->Value(), cb, 1, argv);

}

}

STATEMENT_END();

auto env = info.Env();

Statement* stmt = this;

Baton* baton = stmt->Bind<RowBaton>(info);

if (baton == NULL) {

Napi::Error::New(env, "Data type is not supported").ThrowAsJavaScriptException();

return env.Null();

}

else {

stmt->Schedule(Work_BeginGet, baton);

return info.This();

}

STATEMENT_INIT(RowBaton);

if (stmt->status != SQLITE_DONE || baton->parameters.size()) {

STATEMENT_MUTEX(mtx);

sqlite3_mutex_enter(mtx);

if (stmt->Bind(baton->parameters)) {

stmt->status = sqlite3_step(stmt->_handle);

if (!(stmt->status == SQLITE_ROW || stmt->status == SQLITE_DONE)) {

stmt->message = std::string(sqlite3_errmsg(stmt->db->_handle));

}

}

sqlite3_mutex_leave(mtx);

if (stmt->status == SQLITE_ROW) {

// Acquire one result row before returning.

GetRow(&baton->row, stmt->_handle);

}

}

std::unique_ptr<RowBaton> baton(static_cast<RowBaton*>(data));

auto* stmt = baton->stmt;

auto env = stmt->Env();

Napi::HandleScope scope(env);

if (stmt->status != SQLITE_ROW && stmt->status != SQLITE_DONE) {

Error(baton.get());

}

else {

// Fire callbacks.

Napi::Function cb = baton->callback.Value();

if (IS_FUNCTION(cb)) {

if (stmt->status == SQLITE_ROW) {

// Create the result array from the data we acquired.

Napi::Value argv[] = { env.Null(), RowToJS(env, &baton->row) };

TRY_CATCH_CALL(stmt->Value(), cb, 2, argv);

}

else {

Napi::Value argv[] = { env.Null() };

TRY_CATCH_CALL(stmt->Value(), cb, 1, argv);

}

}

}

STATEMENT_END();

auto env = info.Env();

Statement* stmt = this;

Baton* baton = stmt->Bind<RunBaton>(info);

if (baton == NULL) {

Napi::Error::New(env, "Data type is not supported").ThrowAsJavaScriptException();

return env.Null();

}

else {

stmt->Schedule(Work_BeginRun, baton);

return info.This();

}

STATEMENT_INIT(RunBaton);

STATEMENT_MUTEX(mtx);

sqlite3_mutex_enter(mtx);

// Make sure that we also reset when there are no parameters.

if (!baton->parameters.size()) {

sqlite3_reset(stmt->_handle);

}

if (stmt->Bind(baton->parameters)) {

stmt->status = sqlite3_step(stmt->_handle);

if (!(stmt->status == SQLITE_ROW || stmt->status == SQLITE_DONE)) {

stmt->message = std::string(sqlite3_errmsg(stmt->db->_handle));

}

else {

baton->inserted_id = sqlite3_last_insert_rowid(stmt->db->_handle);

baton->changes = sqlite3_changes(stmt->db->_handle);

}

}

sqlite3_mutex_leave(mtx);

std::unique_ptr<RunBaton> baton(static_cast<RunBaton*>(data));

auto* stmt = baton->stmt;

auto env = stmt->Env();

Napi::HandleScope scope(env);

if (stmt->status != SQLITE_ROW && stmt->status != SQLITE_DONE) {

Error(baton.get());

}

else {

// Fire callbacks.

Napi::Function cb = baton->callback.Value();

if (IS_FUNCTION(cb)) {

(stmt->Value()).Set(Napi::String::New(env, "lastID"), Napi::Number::New(env, baton->inserted_id));

(stmt->Value()).Set( Napi::String::New(env, "changes"), Napi::Number::New(env, baton->changes));

Napi::Value argv[] = { env.Null() };

TRY_CATCH_CALL(stmt->Value(), cb, 1, argv);

}

}

STATEMENT_END();

auto env = info.Env();

Statement* stmt = this;

Baton* baton = stmt->Bind<RowsBaton>(info);

if (baton == NULL) {

Napi::Error::New(env, "Data type is not supported").ThrowAsJavaScriptException();

return env.Null();

}

else {

stmt->Schedule(Work_BeginAll, baton);

return info.This();

}

STATEMENT_INIT(RowsBaton);

STATEMENT_MUTEX(mtx);

sqlite3_mutex_enter(mtx);

// Make sure that we also reset when there are no parameters.

if (!baton->parameters.size()) {

sqlite3_reset(stmt->_handle);

}

if (stmt->Bind(baton->parameters)) {

while ((stmt->status = sqlite3_step(stmt->_handle)) == SQLITE_ROW) {

auto row = std::make_unique<Row>();

GetRow(row.get(), stmt->_handle);

baton->rows.emplace_back(std::move(row));

}

if (stmt->status != SQLITE_DONE) {

stmt->message = std::string(sqlite3_errmsg(stmt->db->_handle));

}

}

sqlite3_mutex_leave(mtx);

std::unique_ptr<RowsBaton> baton(static_cast<RowsBaton*>(data));

auto* stmt = baton->stmt;

auto env = stmt->Env();

Napi::HandleScope scope(env);

if (stmt->status != SQLITE_DONE) {

Error(baton.get());

}

else {

// Fire callbacks.

Napi::Function cb = baton->callback.Value();

if (IS_FUNCTION(cb)) {

if (baton->rows.size()) {

// Create the result array from the data we acquired.

Napi::Array result(Napi::Array::New(env, baton->rows.size()));

auto it = static_cast<Rows::const_iterator>(baton->rows.begin());

decltype(it) end = baton->rows.end();

for (int i = 0; it < end; ++it, i++) {

(result).Set(i, RowToJS(env, it->get()));

}

Napi::Value argv[] = { env.Null(), result };

TRY_CATCH_CALL(stmt->Value(), cb, 2, argv);

}

else {

// There were no result rows.

Napi::Value argv[] = {

env.Null(),

Napi::Array::New(env, 0)

};

TRY_CATCH_CALL(stmt->Value(), cb, 2, argv);

}

}

}

STATEMENT_END();

auto env = info.Env();

Statement* stmt = this;

int last = info.Length();

Napi::Function completed;

if (last >= 2 && info[last - 1].IsFunction() && info[last - 2].IsFunction()) {

completed = info[--last].As<Napi::Function>();

}

auto baton = stmt->Bind<EachBaton>(info, 0, last);

if (baton == NULL) {

Napi::Error::New(env, "Data type is not supported").ThrowAsJavaScriptException();

return env.Null();

}

else {

baton->completed.Reset(completed, 1);

stmt->Schedule(Work_BeginEach, baton);

return info.This();

}

// Only create the Async object when we're actually going into

// the event loop. This prevents dangling events.

auto* each_baton = static_cast<EachBaton*>(baton);

each_baton->async = new Async(each_baton->stmt, reinterpret_cast<uv_async_cb>(AsyncEach));

each_baton->async->item_cb.Reset(each_baton->callback.Value(), 1);

each_baton->async->completed_cb.Reset(each_baton->completed.Value(), 1);

STATEMENT_BEGIN(Each);

STATEMENT_INIT(EachBaton);

auto* async = baton->async;

STATEMENT_MUTEX(mtx);

// Make sure that we also reset when there are no parameters.

if (!baton->parameters.size()) {

sqlite3_reset(stmt->_handle);

}

if (stmt->Bind(baton->parameters)) {

while (true) {

sqlite3_mutex_enter(mtx);

stmt->status = sqlite3_step(stmt->_handle);

if (stmt->status == SQLITE_ROW) {

sqlite3_mutex_leave(mtx);

auto row = std::make_unique<Row>();

GetRow(row.get(), stmt->_handle);

NODE_SQLITE3_MUTEX_LOCK(&async->mutex)

async->data.emplace_back(std::move(row));

NODE_SQLITE3_MUTEX_UNLOCK(&async->mutex)

uv_async_send(&async->watcher);

}

else {

if (stmt->status != SQLITE_DONE) {

stmt->message = std::string(sqlite3_errmsg(stmt->db->_handle));

}

sqlite3_mutex_leave(mtx);

break;

}

}

}

async->completed = true;

uv_async_send(&async->watcher);

assert(handle != NULL);

assert(handle->data != NULL);

auto* async = static_cast<Async*>(handle->data);

delete async;

auto* async = static_cast<Async*>(handle->data);

auto env = async->stmt->Env();

Napi::HandleScope scope(env);

while (true) {

// Get the contents out of the data cache for us to process in the JS callback.

Rows rows;

NODE_SQLITE3_MUTEX_LOCK(&async->mutex)

rows.swap(async->data);

NODE_SQLITE3_MUTEX_UNLOCK(&async->mutex)

if (rows.empty()) {

break;

}

Napi::Function cb = async->item_cb.Value();

if (IS_FUNCTION(cb)) {

Napi::Value argv[2];

argv[0] = env.Null();

for(auto& row : rows) {

argv[1] = RowToJS(env,row.get());

async->retrieved++;

TRY_CATCH_CALL(async->stmt->Value(), cb, 2, argv);

}

}

}

Napi::Function cb = async->completed_cb.Value();

if (async->completed) {

if (!cb.IsEmpty() &&

cb.IsFunction()) {

Napi::Value argv[] = {

env.Null(),

Napi::Number::New(env, async->retrieved)

};

TRY_CATCH_CALL(async->stmt->Value(), cb, 2, argv);

}

uv_close(reinterpret_cast<uv_handle_t*>(handle), CloseCallback);

}

std::unique_ptr<EachBaton> baton(static_cast<EachBaton*>(data));

auto* stmt = baton->stmt;

auto env = stmt->Env();

Napi::HandleScope scope(env);

if (stmt->status != SQLITE_DONE) {

Error(baton.get());

}

STATEMENT_END();

auto env = info.Env();

Statement* stmt = this;

OPTIONAL_ARGUMENT_FUNCTION(0, callback);

auto* baton = new Baton(stmt, callback);

stmt->Schedule(Work_BeginReset, baton);

return info.This();

STATEMENT_INIT(Baton);

sqlite3_reset(stmt->_handle);

stmt->status = SQLITE_OK;

std::unique_ptr<Baton> baton(static_cast<Baton*>(data));

auto* stmt = baton->stmt;

auto env = stmt->Env();

Napi::HandleScope scope(env);

// Fire callbacks.

Napi::Function cb = baton->callback.Value();

if (IS_FUNCTION(cb)) {

Napi::Value argv[] = { env.Null() };

TRY_CATCH_CALL(stmt->Value(), cb, 1, argv);

}

STATEMENT_END();

Napi::EscapableHandleScope scope(env);

auto result = Napi::Object::New(env);

for (auto& field : *row) {

Napi::Value value;

switch (field->type) {

case SQLITE_INTEGER: {

value = Napi::Number::New(env, (static_cast<Values::Integer*>(field.get()))->value);

} break;

case SQLITE_FLOAT: {

value = Napi::Number::New(env, (static_cast<Values::Float*>(field.get()))->value);

} break;

case SQLITE_TEXT: {

value = Napi::String::New(env, (static_cast<Values::Text*>(field.get()))->value.c_str(),

(static_cast<Values::Text*>(field.get()))->value.size());

} break;

case SQLITE_BLOB: {

value = Napi::Buffer<char>::Copy(env, (static_cast<Values::Blob*>(field.get()))->value,

(static_cast<Values::Blob*>(field.get()))->length);

} break;

case SQLITE_NULL: {

value = env.Null();

} break;

}

(result).Set(Napi::String::New(env, field->name.c_str()), value);

}

return scope.Escape(result);

int cols = sqlite3_column_count(stmt);

for (int i = 0; i < cols; i++) {

int type = sqlite3_column_type(stmt, i);

const char* name = sqlite3_column_name(stmt, i);

if (name == NULL) {

assert(false);

}

switch (type) {

case SQLITE_INTEGER: {

row->emplace_back(std::make_unique<Values::Integer>(name, sqlite3_column_int64(stmt, i)));

} break;

case SQLITE_FLOAT: {

row->emplace_back(std::make_unique<Values::Float>(name, sqlite3_column_double(stmt, i)));

} break;

case SQLITE_TEXT: {

const char* text = (const char*)sqlite3_column_text(stmt, i);

int length = sqlite3_column_bytes(stmt, i);

row->emplace_back(std::make_unique<Values::Text>(name, length, text));

} break;

case SQLITE_BLOB: {

const void* blob = sqlite3_column_blob(stmt, i);

int length = sqlite3_column_bytes(stmt, i);

row->emplace_back(std::make_unique<Values::Blob>(name, length, blob));

} break;

case SQLITE_NULL: {

row->emplace_back(std::make_unique<Values::Null>(name));

} break;

default:

assert(false);

}

}

auto env = info.Env();

Statement* stmt = this;

OPTIONAL_ARGUMENT_FUNCTION(0, callback);

auto *baton = new Baton(stmt, callback);

stmt->Schedule(Finalize_, baton);

return stmt->db->Value();

auto baton = std::unique_ptr<Baton>(b);

auto env = baton->stmt->Env();

Napi::HandleScope scope(env);

baton->stmt->Finalize_();

// Fire callback in case there was one.

Napi::Function cb = baton->callback.Value();

if (IS_FUNCTION(cb)) {

TRY_CATCH_CALL(baton->stmt->Value(), cb, 0, NULL);

}

assert(!finalized);

finalized = true;

CleanQueue();

// Finalize returns the status code of the last operation. We already fired

// error events in case those failed.

sqlite3_finalize(_handle);

_handle = NULL;

db->Unref();

auto env = this->Env();

Napi::HandleScope scope(env);

if (prepared && !queue.empty()) {

// This statement has already been prepared and is now finalized.

// Fire error for all remaining items in the queue.

EXCEPTION(Napi::String::New(env, "Statement is already finalized"), SQLITE_MISUSE, exception);

Napi::Value argv[] = { exception };

bool called = false;

// Clear out the queue so that this object can get GC'ed.

while (!queue.empty()) {

auto call = std::unique_ptr<Call>(queue.front());

queue.pop();

auto baton = std::unique_ptr<Baton>(call->baton);

Napi::Function cb = baton->callback.Value();

if (prepared && !cb.IsEmpty() &&

cb.IsFunction()) {

TRY_CATCH_CALL(Value(), cb, 1, argv);

called = true;

}

}

// When we couldn't call a callback function, emit an error on the

// Statement object.

if (!called) {

Napi::Value info[] = { Napi::String::New(env, "error"), exception };

EMIT_EVENT(Value(), 2, info);

}

}

else while (!queue.empty()) {

// Just delete all items in the queue; we already fired an event when

// preparing the statement failed.

auto call = std::unique_ptr<Call>(queue.front());

queue.pop();

// We don't call the actual callback, so we have to make sure that

// the baton gets destroyed.

delete call->baton;

}