Skip to content

N
node-sqlite3
Commit d5b59c31 by Benjamin Byholm
Options

Update for NAN 2.0

parent cc78b514
Showing with 373 additions and 376 deletions
package.json
...@@ -37,7 +37,7 @@ ...@@ -37,7 +37,7 @@
"url": "git://github.com/mapbox/node-sqlite3.git" "url": "git://github.com/mapbox/node-sqlite3.git"
}, },
"dependencies": { "dependencies": {
"nan": "~1.8.4", "nan": "~2.0.5",
"node-pre-gyp": "~0.6.9" "node-pre-gyp": "~0.6.9"
}, },
"bundledDependencies": [ "bundledDependencies": [
......
src/database.cc
#include <string.h> #include <string.h>
#include <node.h>
#include "macros.h" #include "macros.h"
#include "database.h" #include "database.h"
...@@ -7,46 +6,46 @@ ...@@ -7,46 +6,46 @@
using namespace node_sqlite3; using namespace node_sqlite3;
Persistent<FunctionTemplate> Database::constructor_template; Nan::Persistent<FunctionTemplate> Database::constructor_template;
void Database::Init(Handle<Object> target) { NAN_MODULE_INIT(Database::Init) {
NanScope(); Nan::HandleScope scope;
Local<FunctionTemplate> t = NanNew<FunctionTemplate>(New); Local<FunctionTemplate> t = Nan::New<FunctionTemplate>(New);
t->InstanceTemplate()->SetInternalFieldCount(1); t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(NanNew("Database")); t->SetClassName(Nan::New("Database").ToLocalChecked());
NODE_SET_PROTOTYPE_METHOD(t, "close", Close); Nan::SetPrototypeMethod(t, "close", Close);
NODE_SET_PROTOTYPE_METHOD(t, "exec", Exec); Nan::SetPrototypeMethod(t, "exec", Exec);
NODE_SET_PROTOTYPE_METHOD(t, "wait", Wait); Nan::SetPrototypeMethod(t, "wait", Wait);
NODE_SET_PROTOTYPE_METHOD(t, "loadExtension", LoadExtension); Nan::SetPrototypeMethod(t, "loadExtension", LoadExtension);
NODE_SET_PROTOTYPE_METHOD(t, "serialize", Serialize); Nan::SetPrototypeMethod(t, "serialize", Serialize);
NODE_SET_PROTOTYPE_METHOD(t, "parallelize", Parallelize); Nan::SetPrototypeMethod(t, "parallelize", Parallelize);
NODE_SET_PROTOTYPE_METHOD(t, "configure", Configure); Nan::SetPrototypeMethod(t, "configure", Configure);
NODE_SET_GETTER(t, "open", OpenGetter); NODE_SET_GETTER(t, "open", OpenGetter);
NanAssignPersistent(constructor_template, t); constructor_template.Reset(t);
target->Set(NanNew("Database"), Nan::Set(target, Nan::New("Database").ToLocalChecked(),
t->GetFunction()); Nan::GetFunction(t).ToLocalChecked());
} }
void Database::Process() { void Database::Process() {
NanScope(); Nan::HandleScope scope;
if (!open && locked && !queue.empty()) { if (!open && locked && !queue.empty()) {
EXCEPTION(NanNew<String>("Database handle is closed"), SQLITE_MISUSE, exception); EXCEPTION(Nan::New("Database handle is closed").ToLocalChecked(), SQLITE_MISUSE, exception);
Local<Value> argv[] = { exception }; Local<Value> argv[] = { exception };
bool called = false; bool called = false;
// Call all callbacks with the error object. // Call all callbacks with the error object.
while (!queue.empty()) { while (!queue.empty()) {
Call* call = queue.front(); Call* call = queue.front();
Local<Function> cb = NanNew(call->baton->callback); Local<Function> cb = Nan::New(call->baton->callback);
if (!cb.IsEmpty() && cb->IsFunction()) { if (!cb.IsEmpty() && cb->IsFunction()) {
TRY_CATCH_CALL(NanObjectWrapHandle(this), cb, 1, argv); TRY_CATCH_CALL(this->handle(), cb, 1, argv);
called = true; called = true;
} }
queue.pop(); queue.pop();
...@@ -59,8 +58,8 @@ void Database::Process() { ...@@ -59,8 +58,8 @@ void Database::Process() {
// When we couldn't call a callback function, emit an error on the // When we couldn't call a callback function, emit an error on the
// Database object. // Database object.
if (!called) { if (!called) {
Local<Value> args[] = { NanNew("error"), exception }; Local<Value> info[] = { Nan::New("error").ToLocalChecked(), exception };
EMIT_EVENT(NanObjectWrapHandle(this), 2, args); EMIT_EVENT(handle(), 2, info);
} }
return; return;
} }
...@@ -82,17 +81,18 @@ void Database::Process() { ...@@ -82,17 +81,18 @@ void Database::Process() {
} }
void Database::Schedule(Work_Callback callback, Baton* baton, bool exclusive) { void Database::Schedule(Work_Callback callback, Baton* baton, bool exclusive) {
NanScope(); Nan::HandleScope scope;
if (!open && locked) { if (!open && locked) {
EXCEPTION(NanNew<String>("Database is closed"), SQLITE_MISUSE, exception); EXCEPTION(Nan::New("Database is closed").ToLocalChecked(), SQLITE_MISUSE, exception);
Local<Function> cb = NanNew(baton->callback); Local<Function> cb = Nan::New(baton->callback);
if (!cb.IsEmpty() && cb->IsFunction()) { if (!cb.IsEmpty() && cb->IsFunction()) {
Local<Value> argv[] = { exception }; Local<Value> argv[] = { exception };
TRY_CATCH_CALL(NanObjectWrapHandle(this), cb, 1, argv); TRY_CATCH_CALL(handle(), cb, 1, argv);
} }
else { else {
Local<Value> argv[] = { NanNew("error"), exception }; Local<Value> argv[] = { Nan::New("error").ToLocalChecked(), exception };
EMIT_EVENT(NanObjectWrapHandle(this), 2, argv); EMIT_EVENT(handle(), 2, argv);
} }
return; return;
} }
...@@ -107,38 +107,36 @@ void Database::Schedule(Work_Callback callback, Baton* baton, bool exclusive) { ...@@ -107,38 +107,36 @@ void Database::Schedule(Work_Callback callback, Baton* baton, bool exclusive) {
} }
NAN_METHOD(Database::New) { NAN_METHOD(Database::New) {
NanScope(); if (!info.IsConstructCall()) {
return Nan::ThrowTypeError("Use the new operator to create new Database objects");
if (!args.IsConstructCall()) {
return NanThrowTypeError("Use the new operator to create new Database objects");
} }
REQUIRE_ARGUMENT_STRING(0, filename); REQUIRE_ARGUMENT_STRING(0, filename);
int pos = 1; int pos = 1;
int mode; int mode;
if (args.Length() >= pos && args[pos]->IsInt32()) { if (info.Length() >= pos && info[pos]->IsInt32()) {
mode = args[pos++]->Int32Value(); mode = Nan::To<int>(info[pos++]).FromJust();
} else { } else {
mode = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX; mode = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX;
} }
Local<Function> callback; Local<Function> callback;
if (args.Length() >= pos && args[pos]->IsFunction()) { if (info.Length() >= pos && info[pos]->IsFunction()) {
callback = Local<Function>::Cast(args[pos++]); callback = Local<Function>::Cast(info[pos++]);
} }
Database* db = new Database(); Database* db = new Database();
db->Wrap(args.This()); db->Wrap(info.This());
args.This()->ForceSet(NanNew("filename"), args[0]->ToString(), ReadOnly); info.This()->ForceSet(Nan::New("filename").ToLocalChecked(), info[0].As<String>(), ReadOnly);
args.This()->ForceSet(NanNew("mode"), NanNew<Integer>(mode), ReadOnly); info.This()->ForceSet(Nan::New("mode").ToLocalChecked(), Nan::New(mode), ReadOnly);
// Start opening the database. // Start opening the database.
OpenBaton* baton = new OpenBaton(db, callback, *filename, mode); OpenBaton* baton = new OpenBaton(db, callback, *filename, mode);
Work_BeginOpen(baton); Work_BeginOpen(baton);
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
void Database::Work_BeginOpen(Baton* baton) { void Database::Work_BeginOpen(Baton* baton) {
...@@ -170,33 +168,34 @@ void Database::Work_Open(uv_work_t* req) { ...@@ -170,33 +168,34 @@ void Database::Work_Open(uv_work_t* req) {
} }
void Database::Work_AfterOpen(uv_work_t* req) { void Database::Work_AfterOpen(uv_work_t* req) {
NanScope(); Nan::HandleScope scope;
OpenBaton* baton = static_cast<OpenBaton*>(req->data); OpenBaton* baton = static_cast<OpenBaton*>(req->data);
Database* db = baton->db; Database* db = baton->db;
Local<Value> argv[1]; Local<Value> argv[1];
if (baton->status != SQLITE_OK) { if (baton->status != SQLITE_OK) {
EXCEPTION(NanNew<String>(baton->message.c_str()), baton->status, exception); EXCEPTION(Nan::New(baton->message.c_str()).ToLocalChecked(), baton->status, exception);
argv[0] = exception; argv[0] = exception;
} }
else { else {
db->open = true; db->open = true;
argv[0] = NanNew(NanNull()); argv[0] = Nan::Null();
} }
Local<Function> cb = NanNew(baton->callback); Local<Function> cb = Nan::New(baton->callback);
if (!cb.IsEmpty() && cb->IsFunction()) { if (!cb.IsEmpty() && cb->IsFunction()) {
TRY_CATCH_CALL(NanObjectWrapHandle(db), cb, 1, argv); TRY_CATCH_CALL(db->handle(), cb, 1, argv);
} }
else if (!db->open) { else if (!db->open) {
Local<Value> args[] = { NanNew("error"), argv[0] }; Local<Value> info[] = { Nan::New("error").ToLocalChecked(), argv[0] };
EMIT_EVENT(NanObjectWrapHandle(db), 2, args); EMIT_EVENT(db->handle(), 2, info);
} }
if (db->open) { if (db->open) {
Local<Value> args[] = { NanNew("open") }; Local<Value> info[] = { Nan::New("open").ToLocalChecked() };
EMIT_EVENT(NanObjectWrapHandle(db), 1, args); EMIT_EVENT(db->handle(), 1, info);
db->Process(); db->Process();
} }
...@@ -204,20 +203,18 @@ void Database::Work_AfterOpen(uv_work_t* req) { ...@@ -204,20 +203,18 @@ void Database::Work_AfterOpen(uv_work_t* req) {
} }
NAN_GETTER(Database::OpenGetter) { NAN_GETTER(Database::OpenGetter) {
NanScope(); Database* db = Nan::ObjectWrap::Unwrap<Database>(info.This());
Database* db = ObjectWrap::Unwrap<Database>(args.This()); info.GetReturnValue().Set(db->open);
NanReturnValue(NanNew<Boolean>(db->open));
} }
NAN_METHOD(Database::Close) { NAN_METHOD(Database::Close) {
NanScope(); Database* db = Nan::ObjectWrap::Unwrap<Database>(info.This());
Database* db = ObjectWrap::Unwrap<Database>(args.This());
OPTIONAL_ARGUMENT_FUNCTION(0, callback); OPTIONAL_ARGUMENT_FUNCTION(0, callback);
Baton* baton = new Baton(db, callback); Baton* baton = new Baton(db, callback);
db->Schedule(Work_BeginClose, baton, true); db->Schedule(Work_BeginClose, baton, true);
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
void Database::Work_BeginClose(Baton* baton) { void Database::Work_BeginClose(Baton* baton) {
...@@ -247,36 +244,37 @@ void Database::Work_Close(uv_work_t* req) { ...@@ -247,36 +244,37 @@ void Database::Work_Close(uv_work_t* req) {
} }
void Database::Work_AfterClose(uv_work_t* req) { void Database::Work_AfterClose(uv_work_t* req) {
NanScope(); Nan::HandleScope scope;
Baton* baton = static_cast<Baton*>(req->data); Baton* baton = static_cast<Baton*>(req->data);
Database* db = baton->db; Database* db = baton->db;
Local<Value> argv[1]; Local<Value> argv[1];
if (baton->status != SQLITE_OK) { if (baton->status != SQLITE_OK) {
EXCEPTION(NanNew<String>(baton->message.c_str()), baton->status, exception); EXCEPTION(Nan::New(baton->message.c_str()).ToLocalChecked(), baton->status, exception);
argv[0] = exception; argv[0] = exception;
} }
else { else {
db->open = false; db->open = false;
// Leave db->locked to indicate that this db object has reached // Leave db->locked to indicate that this db object has reached
// the end of its life. // the end of its life.
argv[0] = NanNew(NanNull()); argv[0] = Nan::Null();
} }
Local<Function> cb = NanNew(baton->callback); Local<Function> cb = Nan::New(baton->callback);
// Fire callbacks. // Fire callbacks.
if (!cb.IsEmpty() && cb->IsFunction()) { if (!cb.IsEmpty() && cb->IsFunction()) {
TRY_CATCH_CALL(NanObjectWrapHandle(db), cb, 1, argv); TRY_CATCH_CALL(db->handle(), cb, 1, argv);
} }
else if (db->open) { else if (db->open) {
Local<Value> args[] = { NanNew("error"), argv[0] }; Local<Value> info[] = { Nan::New("error").ToLocalChecked(), argv[0] };
EMIT_EVENT(NanObjectWrapHandle(db), 2, args); EMIT_EVENT(db->handle(), 2, info);
} }
if (!db->open) { if (!db->open) {
Local<Value> args[] = { NanNew("close"), argv[0] }; Local<Value> info[] = { Nan::New("close").ToLocalChecked(), argv[0] };
EMIT_EVENT(NanObjectWrapHandle(db), 1, args); EMIT_EVENT(db->handle(), 1, info);
db->Process(); db->Process();
} }
...@@ -284,76 +282,73 @@ void Database::Work_AfterClose(uv_work_t* req) { ...@@ -284,76 +282,73 @@ void Database::Work_AfterClose(uv_work_t* req) {
} }
NAN_METHOD(Database::Serialize) { NAN_METHOD(Database::Serialize) {
NanScope(); Database* db = Nan::ObjectWrap::Unwrap<Database>(info.This());
Database* db = ObjectWrap::Unwrap<Database>(args.This());
OPTIONAL_ARGUMENT_FUNCTION(0, callback); OPTIONAL_ARGUMENT_FUNCTION(0, callback);
bool before = db->serialize; bool before = db->serialize;
db->serialize = true; db->serialize = true;
if (!callback.IsEmpty() && callback->IsFunction()) { if (!callback.IsEmpty() && callback->IsFunction()) {
TRY_CATCH_CALL(args.This(), callback, 0, NULL); TRY_CATCH_CALL(info.This(), callback, 0, NULL);
db->serialize = before; db->serialize = before;
} }
db->Process(); db->Process();
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
NAN_METHOD(Database::Parallelize) { NAN_METHOD(Database::Parallelize) {
NanScope(); Database* db = Nan::ObjectWrap::Unwrap<Database>(info.This());
Database* db = ObjectWrap::Unwrap<Database>(args.This());
OPTIONAL_ARGUMENT_FUNCTION(0, callback); OPTIONAL_ARGUMENT_FUNCTION(0, callback);
bool before = db->serialize; bool before = db->serialize;
db->serialize = false; db->serialize = false;
if (!callback.IsEmpty() && callback->IsFunction()) { if (!callback.IsEmpty() && callback->IsFunction()) {
TRY_CATCH_CALL(args.This(), callback, 0, NULL); TRY_CATCH_CALL(info.This(), callback, 0, NULL);
db->serialize = before; db->serialize = before;
} }
db->Process(); db->Process();
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
NAN_METHOD(Database::Configure) { NAN_METHOD(Database::Configure) {
NanScope(); Database* db = Nan::ObjectWrap::Unwrap<Database>(info.This());
Database* db = ObjectWrap::Unwrap<Database>(args.This());
REQUIRE_ARGUMENTS(2); REQUIRE_ARGUMENTS(2);
if (args[0]->Equals(NanNew("trace"))) { if (Nan::Equals(info[0], Nan::New("trace").ToLocalChecked()).FromJust()) {
Local<Function> handle; Local<Function> handle;
Baton* baton = new Baton(db, handle); Baton* baton = new Baton(db, handle);
db->Schedule(RegisterTraceCallback, baton); db->Schedule(RegisterTraceCallback, baton);
} }
else if (args[0]->Equals(NanNew("profile"))) { else if (Nan::Equals(info[0], Nan::New("profile").ToLocalChecked()).FromJust()) {
Local<Function> handle; Local<Function> handle;
Baton* baton = new Baton(db, handle); Baton* baton = new Baton(db, handle);
db->Schedule(RegisterProfileCallback, baton); db->Schedule(RegisterProfileCallback, baton);
} }
else if (args[0]->Equals(NanNew("busyTimeout"))) { else if (Nan::Equals(info[0], Nan::New("busyTimeout").ToLocalChecked()).FromJust()) {
if (!args[1]->IsInt32()) { if (!info[1]->IsInt32()) {
return NanThrowTypeError("Value must be an integer"); return Nan::ThrowTypeError("Value must be an integer");
} }
Local<Function> handle; Local<Function> handle;
Baton* baton = new Baton(db, handle); Baton* baton = new Baton(db, handle);
baton->status = args[1]->Int32Value(); baton->status = Nan::To<int>(info[1]).FromJust();
db->Schedule(SetBusyTimeout, baton); db->Schedule(SetBusyTimeout, baton);
} }
else { else {
return NanThrowError(Exception::Error(String::Concat( return Nan::ThrowError(Exception::Error(String::Concat(
args[0]->ToString(), Nan::To<String>(info[0]).ToLocalChecked(),
NanNew<String>(" is not a valid configuration option") Nan::New(" is not a valid configuration option").ToLocalChecked()
))); )));
} }
db->Process(); db->Process();
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
void Database::SetBusyTimeout(Baton* baton) { void Database::SetBusyTimeout(Baton* baton) {
...@@ -394,12 +389,13 @@ void Database::TraceCallback(void* db, const char* sql) { ...@@ -394,12 +389,13 @@ void Database::TraceCallback(void* db, const char* sql) {
void Database::TraceCallback(Database* db, std::string* sql) { void Database::TraceCallback(Database* db, std::string* sql) {
// Note: This function is called in the main V8 thread. // Note: This function is called in the main V8 thread.
NanScope(); Nan::HandleScope scope;
Local<Value> argv[] = { Local<Value> argv[] = {
NanNew("trace"), Nan::New("trace").ToLocalChecked(),
NanNew<String>(sql->c_str()) Nan::New(sql->c_str()).ToLocalChecked()
}; };
EMIT_EVENT(NanObjectWrapHandle(db), 2, argv); EMIT_EVENT(db->handle(), 2, argv);
delete sql; delete sql;
} }
...@@ -433,13 +429,14 @@ void Database::ProfileCallback(void* db, const char* sql, sqlite3_uint64 nsecs) ...@@ -433,13 +429,14 @@ void Database::ProfileCallback(void* db, const char* sql, sqlite3_uint64 nsecs)
} }
void Database::ProfileCallback(Database *db, ProfileInfo* info) { void Database::ProfileCallback(Database *db, ProfileInfo* info) {
NanScope(); Nan::HandleScope scope;
Local<Value> argv[] = { Local<Value> argv[] = {
NanNew("profile"), Nan::New("profile").ToLocalChecked(),
NanNew<String>(info->sql.c_str()), Nan::New(info->sql.c_str()).ToLocalChecked(),
NanNew<Number>((double)info->nsecs / 1000000.0) Nan::New<Number>((double)info->nsecs / 1000000.0)
}; };
EMIT_EVENT(NanObjectWrapHandle(db), 3, argv); EMIT_EVENT(db->handle(), 3, argv);
delete info; delete info;
} }
...@@ -476,21 +473,20 @@ void Database::UpdateCallback(void* db, int type, const char* database, ...@@ -476,21 +473,20 @@ void Database::UpdateCallback(void* db, int type, const char* database,
} }
void Database::UpdateCallback(Database *db, UpdateInfo* info) { void Database::UpdateCallback(Database *db, UpdateInfo* info) {
NanScope(); Nan::HandleScope scope;
Local<Value> argv[] = { Local<Value> argv[] = {
NanNew(sqlite_authorizer_string(info->type)), Nan::New(sqlite_authorizer_string(info->type)).ToLocalChecked(),
NanNew<String>(info->database.c_str()), Nan::New(info->database.c_str()).ToLocalChecked(),
NanNew<String>(info->table.c_str()), Nan::New(info->table.c_str()).ToLocalChecked(),
NanNew<Number>(info->rowid), Nan::New<Number>(info->rowid),
}; };
EMIT_EVENT(NanObjectWrapHandle(db), 4, argv); EMIT_EVENT(db->handle(), 4, argv);
delete info; delete info;
} }
NAN_METHOD(Database::Exec) { NAN_METHOD(Database::Exec) {
NanScope(); Database* db = Nan::ObjectWrap::Unwrap<Database>(info.This());
Database* db = ObjectWrap::Unwrap<Database>(args.This());
REQUIRE_ARGUMENT_STRING(0, sql); REQUIRE_ARGUMENT_STRING(0, sql);
OPTIONAL_ARGUMENT_FUNCTION(1, callback); OPTIONAL_ARGUMENT_FUNCTION(1, callback);
...@@ -498,7 +494,7 @@ NAN_METHOD(Database::Exec) { ...@@ -498,7 +494,7 @@ NAN_METHOD(Database::Exec) {
Baton* baton = new ExecBaton(db, callback, *sql); Baton* baton = new ExecBaton(db, callback, *sql);
db->Schedule(Work_BeginExec, baton, true); db->Schedule(Work_BeginExec, baton, true);
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
void Database::Work_BeginExec(Baton* baton) { void Database::Work_BeginExec(Baton* baton) {
...@@ -530,27 +526,28 @@ void Database::Work_Exec(uv_work_t* req) { ...@@ -530,27 +526,28 @@ void Database::Work_Exec(uv_work_t* req) {
} }
void Database::Work_AfterExec(uv_work_t* req) { void Database::Work_AfterExec(uv_work_t* req) {
NanScope(); Nan::HandleScope scope;
ExecBaton* baton = static_cast<ExecBaton*>(req->data); ExecBaton* baton = static_cast<ExecBaton*>(req->data);
Database* db = baton->db; Database* db = baton->db;
Local<Function> cb = NanNew(baton->callback); Local<Function> cb = Nan::New(baton->callback);
if (baton->status != SQLITE_OK) { if (baton->status != SQLITE_OK) {
EXCEPTION(NanNew<String>(baton->message.c_str()), baton->status, exception); EXCEPTION(Nan::New(baton->message.c_str()).ToLocalChecked(), baton->status, exception);
if (!cb.IsEmpty() && cb->IsFunction()) { if (!cb.IsEmpty() && cb->IsFunction()) {
Local<Value> argv[] = { exception }; Local<Value> argv[] = { exception };
TRY_CATCH_CALL(NanObjectWrapHandle(db), cb, 1, argv); TRY_CATCH_CALL(db->handle(), cb, 1, argv);
} }
else { else {
Local<Value> args[] = { NanNew("error"), exception }; Local<Value> info[] = { Nan::New("error").ToLocalChecked(), exception };
EMIT_EVENT(NanObjectWrapHandle(db), 2, args); EMIT_EVENT(db->handle(), 2, info);
} }
} }
else if (!cb.IsEmpty() && cb->IsFunction()) { else if (!cb.IsEmpty() && cb->IsFunction()) {
Local<Value> argv[] = { NanNew(NanNull()) }; Local<Value> argv[] = { Nan::Null() };
TRY_CATCH_CALL(NanObjectWrapHandle(db), cb, 1, argv); TRY_CATCH_CALL(db->handle(), cb, 1, argv);
} }
db->Process(); db->Process();
...@@ -559,29 +556,28 @@ void Database::Work_AfterExec(uv_work_t* req) { ...@@ -559,29 +556,28 @@ void Database::Work_AfterExec(uv_work_t* req) {
} }
NAN_METHOD(Database::Wait) { NAN_METHOD(Database::Wait) {
NanScope(); Database* db = Nan::ObjectWrap::Unwrap<Database>(info.This());
Database* db = ObjectWrap::Unwrap<Database>(args.This());
OPTIONAL_ARGUMENT_FUNCTION(0, callback); OPTIONAL_ARGUMENT_FUNCTION(0, callback);
Baton* baton = new Baton(db, callback); Baton* baton = new Baton(db, callback);
db->Schedule(Work_Wait, baton, true); db->Schedule(Work_Wait, baton, true);
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
void Database::Work_Wait(Baton* baton) { void Database::Work_Wait(Baton* baton) {
NanScope(); Nan::HandleScope scope;
assert(baton->db->locked); assert(baton->db->locked);
assert(baton->db->open); assert(baton->db->open);
assert(baton->db->_handle); assert(baton->db->_handle);
assert(baton->db->pending == 0); assert(baton->db->pending == 0);
Local<Function> cb = NanNew(baton->callback); Local<Function> cb = Nan::New(baton->callback);
if (!cb.IsEmpty() && cb->IsFunction()) { if (!cb.IsEmpty() && cb->IsFunction()) {
Local<Value> argv[] = { NanNew(NanNull()) }; Local<Value> argv[] = { Nan::Null() };
TRY_CATCH_CALL(NanObjectWrapHandle(baton->db), cb, 1, argv); TRY_CATCH_CALL(baton->db->handle(), cb, 1, argv);
} }
baton->db->Process(); baton->db->Process();
...@@ -590,8 +586,7 @@ void Database::Work_Wait(Baton* baton) { ...@@ -590,8 +586,7 @@ void Database::Work_Wait(Baton* baton) {
} }
NAN_METHOD(Database::LoadExtension) { NAN_METHOD(Database::LoadExtension) {
NanScope(); Database* db = Nan::ObjectWrap::Unwrap<Database>(info.This());
Database* db = ObjectWrap::Unwrap<Database>(args.This());
REQUIRE_ARGUMENT_STRING(0, filename); REQUIRE_ARGUMENT_STRING(0, filename);
OPTIONAL_ARGUMENT_FUNCTION(1, callback); OPTIONAL_ARGUMENT_FUNCTION(1, callback);
...@@ -599,7 +594,7 @@ NAN_METHOD(Database::LoadExtension) { ...@@ -599,7 +594,7 @@ NAN_METHOD(Database::LoadExtension) {
Baton* baton = new LoadExtensionBaton(db, callback, *filename); Baton* baton = new LoadExtensionBaton(db, callback, *filename);
db->Schedule(Work_BeginLoadExtension, baton, true); db->Schedule(Work_BeginLoadExtension, baton, true);
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
void Database::Work_BeginLoadExtension(Baton* baton) { void Database::Work_BeginLoadExtension(Baton* baton) {
...@@ -608,7 +603,7 @@ void Database::Work_BeginLoadExtension(Baton* baton) { ...@@ -608,7 +603,7 @@ void Database::Work_BeginLoadExtension(Baton* baton) {
assert(baton->db->_handle); assert(baton->db->_handle);
assert(baton->db->pending == 0); assert(baton->db->pending == 0);
int status = uv_queue_work(uv_default_loop(), int status = uv_queue_work(uv_default_loop(),
&baton->request, Work_LoadExtension, (uv_after_work_cb)Work_AfterLoadExtension); &baton->request, Work_LoadExtension, reinterpret_cast<uv_after_work_cb>(Work_AfterLoadExtension));
assert(status == 0); assert(status == 0);
} }
...@@ -634,26 +629,27 @@ void Database::Work_LoadExtension(uv_work_t* req) { ...@@ -634,26 +629,27 @@ void Database::Work_LoadExtension(uv_work_t* req) {
} }
void Database::Work_AfterLoadExtension(uv_work_t* req) { void Database::Work_AfterLoadExtension(uv_work_t* req) {
NanScope(); Nan::HandleScope scope;
LoadExtensionBaton* baton = static_cast<LoadExtensionBaton*>(req->data); LoadExtensionBaton* baton = static_cast<LoadExtensionBaton*>(req->data);
Database* db = baton->db; Database* db = baton->db;
Local<Function> cb = NanNew(baton->callback); Local<Function> cb = Nan::New(baton->callback);
if (baton->status != SQLITE_OK) { if (baton->status != SQLITE_OK) {
EXCEPTION(NanNew<String>(baton->message.c_str()), baton->status, exception); EXCEPTION(Nan::New(baton->message.c_str()).ToLocalChecked(), baton->status, exception);
if (!cb.IsEmpty() && cb->IsFunction()) { if (!cb.IsEmpty() && cb->IsFunction()) {
Local<Value> argv[] = { exception }; Local<Value> argv[] = { exception };
TRY_CATCH_CALL(NanObjectWrapHandle(db), cb, 1, argv); TRY_CATCH_CALL(db->handle(), cb, 1, argv);
} }
else { else {
Local<Value> args[] = { NanNew("error"), exception }; Local<Value> info[] = { Nan::New("error").ToLocalChecked(), exception };
EMIT_EVENT(NanObjectWrapHandle(db), 2, args); EMIT_EVENT(db->handle(), 2, info);
} }
} }
else if (!cb.IsEmpty() && cb->IsFunction()) { else if (!cb.IsEmpty() && cb->IsFunction()) {
Local<Value> argv[] = { NanNew(NanNull()) }; Local<Value> argv[] = { Nan::Null() };
TRY_CATCH_CALL(NanObjectWrapHandle(db), cb, 1, argv); TRY_CATCH_CALL(db->handle(), cb, 1, argv);
} }
db->Process(); db->Process();
......
src/database.h
...@@ -2,70 +2,69 @@ ...@@ -2,70 +2,69 @@
#ifndef NODE_SQLITE3_SRC_DATABASE_H #ifndef NODE_SQLITE3_SRC_DATABASE_H
#define NODE_SQLITE3_SRC_DATABASE_H #define NODE_SQLITE3_SRC_DATABASE_H
#include <node.h>
#include <string> #include <string>
#include <queue> #include <queue>
#include <sqlite3.h> #include <sqlite3.h>
#include "nan.h" #include <nan.h>
#include "async.h" #include "async.h"
using namespace v8; using namespace v8;
using namespace node;
namespace node_sqlite3 { namespace node_sqlite3 {
class Database; class Database;
class Database : public ObjectWrap { class Database : public Nan::ObjectWrap {
public: public:
static Persistent<FunctionTemplate> constructor_template; static Nan::Persistent<FunctionTemplate> constructor_template;
static void Init(Handle<Object> target); static NAN_MODULE_INIT(Init);
static inline bool HasInstance(Handle<Value> val) { static inline bool HasInstance(Local<Value> val) {
NanScope(); Nan::HandleScope scope;
if (!val->IsObject()) return false; if (!val->IsObject()) return false;
Local<Object> obj = val->ToObject(); Local<Object> obj = val.As<Object>();
return NanNew(constructor_template)->HasInstance(obj); return Nan::New(constructor_template)->HasInstance(obj);
} }
struct Baton { struct Baton {
uv_work_t request; uv_work_t request;
Database* db; Database* db;
Persistent<Function> callback; Nan::Persistent<Function> callback;
int status; int status;
std::string message; std::string message;
Baton(Database* db_, Handle<Function> cb_) : Baton(Database* db_, Local<Function> cb_) :
db(db_), status(SQLITE_OK) { db(db_), status(SQLITE_OK) {
db->Ref(); db->Ref();
request.data = this; request.data = this;
NanAssignPersistent(callback, cb_); callback.Reset(cb_);
} }
virtual ~Baton() { virtual ~Baton() {
db->Unref(); db->Unref();
NanDisposePersistent(callback); callback.Reset();
} }
}; };
struct OpenBaton : Baton { struct OpenBaton : Baton {
std::string filename; std::string filename;
int mode; int mode;
OpenBaton(Database* db_, Handle<Function> cb_, const char* filename_, int mode_) : OpenBaton(Database* db_, Local<Function> cb_, const char* filename_, int mode_) :
Baton(db_, cb_), filename(filename_), mode(mode_) {} Baton(db_, cb_), filename(filename_), mode(mode_) {}
}; };
struct ExecBaton : Baton { struct ExecBaton : Baton {
std::string sql; std::string sql;
ExecBaton(Database* db_, Handle<Function> cb_, const char* sql_) : ExecBaton(Database* db_, Local<Function> cb_, const char* sql_) :
Baton(db_, cb_), sql(sql_) {} Baton(db_, cb_), sql(sql_) {}
}; };
struct LoadExtensionBaton : Baton { struct LoadExtensionBaton : Baton {
std::string filename; std::string filename;
LoadExtensionBaton(Database* db_, Handle<Function> cb_, const char* filename_) : LoadExtensionBaton(Database* db_, Local<Function> cb_, const char* filename_) :
Baton(db_, cb_), filename(filename_) {} Baton(db_, cb_), filename(filename_) {}
}; };
...@@ -101,7 +100,7 @@ public: ...@@ -101,7 +100,7 @@ public:
friend class Statement; friend class Statement;
protected: protected:
Database() : ObjectWrap(), Database() : Nan::ObjectWrap(),
_handle(NULL), _handle(NULL),
open(false), open(false),
locked(false), locked(false),
......
src/macros.h
...@@ -6,104 +6,107 @@ const char* sqlite_authorizer_string(int type); ...@@ -6,104 +6,107 @@ const char* sqlite_authorizer_string(int type);
#define REQUIRE_ARGUMENTS(n) \ #define REQUIRE_ARGUMENTS(n) \
if (args.Length() < (n)) { \ if (info.Length() < (n)) { \
return NanThrowTypeError("Expected " #n "arguments"); \ return Nan::ThrowTypeError("Expected " #n "arguments"); \
} }
#define REQUIRE_ARGUMENT_EXTERNAL(i, var) \ #define REQUIRE_ARGUMENT_EXTERNAL(i, var) \
if (args.Length() <= (i) || !args[i]->IsExternal()) { \ if (info.Length() <= (i) || !info[i]->IsExternal()) { \
return NanThrowTypeError("Argument " #i " invalid"); \ return Nan::ThrowTypeError("Argument " #i " invalid"); \
} \ } \
Local<External> var = Local<External>::Cast(args[i]); Local<External> var = Local<External>::Cast(info[i]);
#define REQUIRE_ARGUMENT_FUNCTION(i, var) \ #define REQUIRE_ARGUMENT_FUNCTION(i, var) \
if (args.Length() <= (i) || !args[i]->IsFunction()) { \ if (info.Length() <= (i) || !info[i]->IsFunction()) { \
return NanThrowTypeError("Argument " #i " must be a function"); \ return Nan::ThrowTypeError("Argument " #i " must be a function"); \
} \ } \
Local<Function> var = Local<Function>::Cast(args[i]); Local<Function> var = Local<Function>::Cast(info[i]);
#define REQUIRE_ARGUMENT_STRING(i, var) \ #define REQUIRE_ARGUMENT_STRING(i, var) \
if (args.Length() <= (i) || !args[i]->IsString()) { \ if (info.Length() <= (i) || !info[i]->IsString()) { \
return NanThrowTypeError("Argument " #i " must be a string"); \ return Nan::ThrowTypeError("Argument " #i " must be a string"); \
} \ } \
String::Utf8Value var(args[i]->ToString()); Nan::Utf8String var(info[i]);
#define OPTIONAL_ARGUMENT_FUNCTION(i, var) \ #define OPTIONAL_ARGUMENT_FUNCTION(i, var) \
Local<Function> var; \ Local<Function> var; \
if (args.Length() > i && !args[i]->IsUndefined()) { \ if (info.Length() > i && !info[i]->IsUndefined()) { \
if (!args[i]->IsFunction()) { \ if (!info[i]->IsFunction()) { \
return NanThrowTypeError("Argument " #i " must be a function"); \ return Nan::ThrowTypeError("Argument " #i " must be a function"); \
} \ } \
var = Local<Function>::Cast(args[i]); \ var = Local<Function>::Cast(info[i]); \
} }
#define OPTIONAL_ARGUMENT_INTEGER(i, var, default) \ #define OPTIONAL_ARGUMENT_INTEGER(i, var, default) \
int var; \ int var; \
if (args.Length() <= (i)) { \ if (info.Length() <= (i)) { \
var = (default); \ var = (default); \
} \ } \
else if (args[i]->IsInt32()) { \ else if (info[i]->IsInt32()) { \
var = args[i]->Int32Value(); \ var = Nan::To<int32_t>(info[i]).FromJust(); \
} \ } \
else { \ else { \
return NanThrowTypeError("Argument " #i " must be an integer"); \ return Nan::ThrowTypeError("Argument " #i " must be an integer"); \
} }
#define DEFINE_CONSTANT_INTEGER(target, constant, name) \ #define DEFINE_CONSTANT_INTEGER(target, constant, name) \
(target)->ForceSet( \ Nan::ForceSet(target, \
NanNew(#name), \ Nan::New(#name).ToLocalChecked(), \
NanNew<Integer>(constant), \ Nan::New<Integer>(constant), \
static_cast<PropertyAttribute>(ReadOnly | DontDelete) \ static_cast<PropertyAttribute>(ReadOnly | DontDelete) \
); );
#define DEFINE_CONSTANT_STRING(target, constant, name) \ #define DEFINE_CONSTANT_STRING(target, constant, name) \
(target)->ForceSet( \ Nan::ForceSet(target, \
NanNew(#name), \ Nan::New(#name).ToLocalChecked(), \
NanNew(constant), \ Nan::New(constant).ToLocalChecked(), \
static_cast<PropertyAttribute>(ReadOnly | DontDelete) \ static_cast<PropertyAttribute>(ReadOnly | DontDelete) \
); );
#define NODE_SET_GETTER(target, name, function) \ #define NODE_SET_GETTER(target, name, function) \
(target)->InstanceTemplate() \ Nan::SetAccessor((target)->InstanceTemplate(), \
->SetAccessor(NanNew(name), (function)); Nan::New(name).ToLocalChecked(), (function));
#define GET_STRING(source, name, property) \ #define GET_STRING(source, name, property) \
String::Utf8Value name((source)->Get(NanNew(property))); Nan::Utf8String name(Nan::Get(source, \
Nan::New(prop).ToLocalChecked()).ToLocalChecked());
#define GET_INTEGER(source, name, property) \ #define GET_INTEGER(source, name, prop) \
int name = (source)->Get(NanNew(property))->Int32Value(); int name = Nan::To<int>(Nan::Get(source, \
Nan::New(property).ToLocalChecked()).ToLocalChecked()).FromJust();
#define EXCEPTION(msg, errno, name) \ #define EXCEPTION(msg, errno, name) \
Local<Value> name = Exception::Error( \ Local<Value> name = Exception::Error( \
String::Concat( \ String::Concat( \
String::Concat( \ String::Concat( \
NanNew(sqlite_code_string(errno)), \ Nan::New(sqlite_code_string(errno)).ToLocalChecked(), \
NanNew(": ") \ Nan::New(": ").ToLocalChecked() \
), \ ), \
(msg) \ (msg) \
) \ ) \
); \ ); \
Local<Object> name ##_obj = name->ToObject(); \ Local<Object> name ##_obj = name.As<Object>(); \
name ##_obj->Set(NanNew("errno"), NanNew<Integer>(errno)); \ Nan::Set(name ##_obj, Nan::New("errno").ToLocalChecked(), Nan::New(errno));\
name ##_obj->Set(NanNew("code"), \ Nan::Set(name ##_obj, Nan::New("code").ToLocalChecked(), \
NanNew(sqlite_code_string(errno))); Nan::New(sqlite_code_string(errno)).ToLocalChecked());
#define EMIT_EVENT(obj, argc, argv) \ #define EMIT_EVENT(obj, argc, argv) \
TRY_CATCH_CALL((obj), \ TRY_CATCH_CALL((obj), \
Local<Function>::Cast((obj)->Get(NanNew("emit"))), \ Nan::Get(obj, \
Nan::New("emit").ToLocalChecked()).ToLocalChecked().As<Function>(),\
argc, argv \ argc, argv \
); );
#define TRY_CATCH_CALL(context, callback, argc, argv) \ #define TRY_CATCH_CALL(context, callback, argc, argv) \
NanMakeCallback((context), (callback), (argc), (argv)) Nan::MakeCallback((context), (callback), (argc), (argv))
#define WORK_DEFINITION(name) \ #define WORK_DEFINITION(name) \
static NAN_METHOD(name); \ static NAN_METHOD(name); \
...@@ -120,7 +123,8 @@ const char* sqlite_authorizer_string(int type); ...@@ -120,7 +123,8 @@ const char* sqlite_authorizer_string(int type);
baton->stmt->locked = true; \ baton->stmt->locked = true; \
baton->stmt->db->pending++; \ baton->stmt->db->pending++; \
int status = uv_queue_work(uv_default_loop(), \ int status = uv_queue_work(uv_default_loop(), \
&baton->request, Work_##type, (uv_after_work_cb)Work_After##type); \ &baton->request, \
Work_##type, reinterpret_cast<uv_after_work_cb>(Work_After##type)); \
assert(status == 0); assert(status == 0);
#define STATEMENT_INIT(type) \ #define STATEMENT_INIT(type) \
......
src/node_sqlite3.cc
#include <node.h>
#include <node_buffer.h>
#include <stdint.h> #include <stdint.h>
#include <sstream> #include <sstream>
#include <cstring> #include <cstring>
...@@ -15,8 +12,9 @@ using namespace node_sqlite3; ...@@ -15,8 +12,9 @@ using namespace node_sqlite3;
namespace { namespace {
void RegisterModule(v8::Handle<Object> target) { NAN_MODULE_INIT(RegisterModule) {
NanScope(); Nan::HandleScope scope;
Database::Init(target); Database::Init(target);
Statement::Init(target); Statement::Init(target);
......
src/statement.cc
...@@ -9,27 +9,27 @@ ...@@ -9,27 +9,27 @@
using namespace node_sqlite3; using namespace node_sqlite3;
Persistent<FunctionTemplate> Statement::constructor_template; Nan::Persistent<FunctionTemplate> Statement::constructor_template;
void Statement::Init(Handle<Object> target) { NAN_MODULE_INIT(Statement::Init) {
NanScope(); Nan::HandleScope scope;
Local<FunctionTemplate> t = NanNew<FunctionTemplate>(New); Local<FunctionTemplate> t = Nan::New<FunctionTemplate>(New);
t->InstanceTemplate()->SetInternalFieldCount(1); t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(NanNew("Statement")); t->SetClassName(Nan::New("Statement").ToLocalChecked());
NODE_SET_PROTOTYPE_METHOD(t, "bind", Bind); Nan::SetPrototypeMethod(t, "bind", Bind);
NODE_SET_PROTOTYPE_METHOD(t, "get", Get); Nan::SetPrototypeMethod(t, "get", Get);
NODE_SET_PROTOTYPE_METHOD(t, "run", Run); Nan::SetPrototypeMethod(t, "run", Run);
NODE_SET_PROTOTYPE_METHOD(t, "all", All); Nan::SetPrototypeMethod(t, "all", All);
NODE_SET_PROTOTYPE_METHOD(t, "each", Each); Nan::SetPrototypeMethod(t, "each", Each);
NODE_SET_PROTOTYPE_METHOD(t, "reset", Reset); Nan::SetPrototypeMethod(t, "reset", Reset);
NODE_SET_PROTOTYPE_METHOD(t, "finalize", Finalize); Nan::SetPrototypeMethod(t, "finalize", Finalize);
NanAssignPersistent(constructor_template, t); constructor_template.Reset(t);
target->Set(NanNew("Statement"), Nan::Set(target, Nan::New("Statement").ToLocalChecked(),
t->GetFunction()); Nan::GetFunction(t).ToLocalChecked());
} }
void Statement::Process() { void Statement::Process() {
...@@ -60,58 +60,56 @@ void Statement::Schedule(Work_Callback callback, Baton* baton) { ...@@ -60,58 +60,56 @@ void Statement::Schedule(Work_Callback callback, Baton* baton) {
} }
template <class T> void Statement::Error(T* baton) { template <class T> void Statement::Error(T* baton) {
NanScope(); Nan::HandleScope scope;
Statement* stmt = baton->stmt; Statement* stmt = baton->stmt;
// Fail hard on logic errors. // Fail hard on logic errors.
assert(stmt->status != 0); assert(stmt->status != 0);
EXCEPTION(NanNew<String>(stmt->message.c_str()), stmt->status, exception); EXCEPTION(Nan::New(stmt->message.c_str()).ToLocalChecked(), stmt->status, exception);
Local<Function> cb = NanNew(baton->callback); Local<Function> cb = Nan::New(baton->callback);
if (!cb.IsEmpty() && cb->IsFunction()) { if (!cb.IsEmpty() && cb->IsFunction()) {
Local<Value> argv[] = { exception }; Local<Value> argv[] = { exception };
TRY_CATCH_CALL(NanObjectWrapHandle(stmt), cb, 1, argv); TRY_CATCH_CALL(stmt->handle(), cb, 1, argv);
} }
else { else {
Local<Value> argv[] = { NanNew("error"), exception }; Local<Value> argv[] = { Nan::New("error").ToLocalChecked(), exception };
EMIT_EVENT(NanObjectWrapHandle(stmt), 2, argv); EMIT_EVENT(stmt->handle(), 2, argv);
} }
} }
// { Database db, String sql, Array params, Function callback } // { Database db, String sql, Array params, Function callback }
NAN_METHOD(Statement::New) { NAN_METHOD(Statement::New) {
NanScope(); if (!info.IsConstructCall()) {
return Nan::ThrowTypeError("Use the new operator to create new Statement objects");
if (!args.IsConstructCall()) {
return NanThrowTypeError("Use the new operator to create new Statement objects");
} }
int length = args.Length(); int length = info.Length();
if (length <= 0 || !Database::HasInstance(args[0])) { if (length <= 0 || !Database::HasInstance(info[0])) {
return NanThrowTypeError("Database object expected"); return Nan::ThrowTypeError("Database object expected");
} }
else if (length <= 1 || !args[1]->IsString()) { else if (length <= 1 || !info[1]->IsString()) {
return NanThrowTypeError("SQL query expected"); return Nan::ThrowTypeError("SQL query expected");
} }
else if (length > 2 && !args[2]->IsUndefined() && !args[2]->IsFunction()) { else if (length > 2 && !info[2]->IsUndefined() && !info[2]->IsFunction()) {
return NanThrowTypeError("Callback expected"); return Nan::ThrowTypeError("Callback expected");
} }
Database* db = ObjectWrap::Unwrap<Database>(args[0]->ToObject()); Database* db = Nan::ObjectWrap::Unwrap<Database>(info[0].As<Object>());
Local<String> sql = Local<String>::Cast(args[1]); Local<String> sql = Local<String>::Cast(info[1]);
args.This()->ForceSet(NanNew("sql"), sql, ReadOnly); info.This()->ForceSet(Nan::New("sql").ToLocalChecked(), sql, ReadOnly);
Statement* stmt = new Statement(db); Statement* stmt = new Statement(db);
stmt->Wrap(args.This()); stmt->Wrap(info.This());
PrepareBaton* baton = new PrepareBaton(db, Local<Function>::Cast(args[2]), stmt); PrepareBaton* baton = new PrepareBaton(db, Local<Function>::Cast(info[2]), stmt);
baton->sql = std::string(*String::Utf8Value(sql)); baton->sql = std::string(*Nan::Utf8String(sql));
db->Schedule(Work_BeginPrepare, baton); db->Schedule(Work_BeginPrepare, baton);
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
void Statement::Work_BeginPrepare(Database::Baton* baton) { void Statement::Work_BeginPrepare(Database::Baton* baton) {
...@@ -147,7 +145,8 @@ void Statement::Work_Prepare(uv_work_t* req) { ...@@ -147,7 +145,8 @@ void Statement::Work_Prepare(uv_work_t* req) {
} }
void Statement::Work_AfterPrepare(uv_work_t* req) { void Statement::Work_AfterPrepare(uv_work_t* req) {
NanScope(); Nan::HandleScope scope;
STATEMENT_INIT(PrepareBaton); STATEMENT_INIT(PrepareBaton);
if (stmt->status != SQLITE_OK) { if (stmt->status != SQLITE_OK) {
...@@ -156,10 +155,10 @@ void Statement::Work_AfterPrepare(uv_work_t* req) { ...@@ -156,10 +155,10 @@ void Statement::Work_AfterPrepare(uv_work_t* req) {
} }
else { else {
stmt->prepared = true; stmt->prepared = true;
Local<Function> cb = NanNew(baton->callback); Local<Function> cb = Nan::New(baton->callback);
if (!cb.IsEmpty() && cb->IsFunction()) { if (!cb.IsEmpty() && cb->IsFunction()) {
Local<Value> argv[] = { NanNew(NanNull()) }; Local<Value> argv[] = { Nan::Null() };
TRY_CATCH_CALL(NanObjectWrapHandle(stmt), cb, 1, argv); TRY_CATCH_CALL(stmt->handle(), cb, 1, argv);
} }
} }
...@@ -167,77 +166,77 @@ void Statement::Work_AfterPrepare(uv_work_t* req) { ...@@ -167,77 +166,77 @@ void Statement::Work_AfterPrepare(uv_work_t* req) {
} }
template <class T> Values::Field* template <class T> Values::Field*
Statement::BindParameter(const Handle<Value> source, T pos) { Statement::BindParameter(const Local<Value> source, T pos) {
if (source->IsString() || source->IsRegExp()) { if (source->IsString() || source->IsRegExp()) {
String::Utf8Value val(source->ToString()); Nan::Utf8String val(source);
return new Values::Text(pos, val.length(), *val); return new Values::Text(pos, val.length(), *val);
} }
else if (source->IsInt32()) { else if (source->IsInt32()) {
return new Values::Integer(pos, source->Int32Value()); return new Values::Integer(pos, Nan::To<int32_t>(source).FromJust());
} }
else if (source->IsNumber()) { else if (source->IsNumber()) {
return new Values::Float(pos, source->NumberValue()); return new Values::Float(pos, Nan::To<double>(source).FromJust());
} }
else if (source->IsBoolean()) { else if (source->IsBoolean()) {
return new Values::Integer(pos, source->BooleanValue() ? 1 : 0); return new Values::Integer(pos, Nan::To<bool>(source).FromJust() ? 1 : 0);
} }
else if (source->IsNull()) { else if (source->IsNull()) {
return new Values::Null(pos); return new Values::Null(pos);
} }
else if (Buffer::HasInstance(source)) { else if (Buffer::HasInstance(source)) {
Local<Object> buffer = source->ToObject(); Local<Object> buffer = Nan::To<Object>(source).ToLocalChecked();
return new Values::Blob(pos, Buffer::Length(buffer), Buffer::Data(buffer)); return new Values::Blob(pos, Buffer::Length(buffer), Buffer::Data(buffer));
} }
else if (source->IsDate()) { else if (source->IsDate()) {
return new Values::Float(pos, source->NumberValue()); return new Values::Float(pos, Nan::To<double>(source).FromJust());
} }
else { else {
return NULL; return NULL;
} }
} }
template <class T> T* Statement::Bind(_NAN_METHOD_ARGS, int start, int last) { template <class T> T* Statement::Bind(Nan::NAN_METHOD_ARGS_TYPE info, int start, int last) {
NanScope(); Nan::HandleScope scope;
if (last < 0) last = args.Length(); if (last < 0) last = info.Length();
Local<Function> callback; Local<Function> callback;
if (last > start && args[last - 1]->IsFunction()) { if (last > start && info[last - 1]->IsFunction()) {
callback = Local<Function>::Cast(args[last - 1]); callback = Local<Function>::Cast(info[last - 1]);
last--; last--;
} }
T* baton = new T(this, callback); T* baton = new T(this, callback);
if (start < last) { if (start < last) {
if (args[start]->IsArray()) { if (info[start]->IsArray()) {
Local<Array> array = Local<Array>::Cast(args[start]); Local<Array> array = Local<Array>::Cast(info[start]);
int length = array->Length(); int length = array->Length();
// Note: bind parameters start with 1. // Note: bind parameters start with 1.
for (int i = 0, pos = 1; i < length; i++, pos++) { for (int i = 0, pos = 1; i < length; i++, pos++) {
baton->parameters.push_back(BindParameter(array->Get(i), pos)); baton->parameters.push_back(BindParameter(Nan::Get(array, i).ToLocalChecked(), pos));
} }
} }
else if (!args[start]->IsObject() || args[start]->IsRegExp() || args[start]->IsDate() || Buffer::HasInstance(args[start])) { else if (!info[start]->IsObject() || info[start]->IsRegExp() || info[start]->IsDate() || Buffer::HasInstance(info[start])) {
// Parameters directly in array. // Parameters directly in array.
// Note: bind parameters start with 1. // Note: bind parameters start with 1.
for (int i = start, pos = 1; i < last; i++, pos++) { for (int i = start, pos = 1; i < last; i++, pos++) {
baton->parameters.push_back(BindParameter(args[i], pos)); baton->parameters.push_back(BindParameter(info[i], pos));
} }
} }
else if (args[start]->IsObject()) { else if (info[start]->IsObject()) {
Local<Object> object = Local<Object>::Cast(args[start]); Local<Object> object = Local<Object>::Cast(info[start]);
Local<Array> array = object->GetPropertyNames(); Local<Array> array = Nan::GetPropertyNames(object).ToLocalChecked();
int length = array->Length(); int length = array->Length();
for (int i = 0; i < length; i++) { for (int i = 0; i < length; i++) {
Local<Value> name = array->Get(i); Local<Value> name = Nan::Get(array, i).ToLocalChecked();
if (name->IsInt32()) { if (name->IsInt32()) {
baton->parameters.push_back( baton->parameters.push_back(
BindParameter(object->Get(name), name->Int32Value())); BindParameter(Nan::Get(object, name).ToLocalChecked(), Nan::To<int32_t>(name).FromJust()));
} }
else { else {
baton->parameters.push_back(BindParameter(object->Get(name), baton->parameters.push_back(BindParameter(Nan::Get(object, name).ToLocalChecked(),
*String::Utf8Value(Local<String>::Cast(name)))); *Nan::Utf8String(name)));
} }
} }
} }
...@@ -307,16 +306,15 @@ bool Statement::Bind(const Parameters & parameters) { ...@@ -307,16 +306,15 @@ bool Statement::Bind(const Parameters & parameters) {
} }
NAN_METHOD(Statement::Bind) { NAN_METHOD(Statement::Bind) {
NanScope(); Statement* stmt = Nan::ObjectWrap::Unwrap<Statement>(info.This());
Statement* stmt = ObjectWrap::Unwrap<Statement>(args.This());
Baton* baton = stmt->Bind<Baton>(args); Baton* baton = stmt->Bind<Baton>(info);
if (baton == NULL) { if (baton == NULL) {
return NanThrowTypeError("Data type is not supported"); return Nan::ThrowTypeError("Data type is not supported");
} }
else { else {
stmt->Schedule(Work_BeginBind, baton); stmt->Schedule(Work_BeginBind, baton);
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
} }
...@@ -334,7 +332,8 @@ void Statement::Work_Bind(uv_work_t* req) { ...@@ -334,7 +332,8 @@ void Statement::Work_Bind(uv_work_t* req) {
} }
void Statement::Work_AfterBind(uv_work_t* req) { void Statement::Work_AfterBind(uv_work_t* req) {
NanScope(); Nan::HandleScope scope;
STATEMENT_INIT(Baton); STATEMENT_INIT(Baton);
if (stmt->status != SQLITE_OK) { if (stmt->status != SQLITE_OK) {
...@@ -342,10 +341,10 @@ void Statement::Work_AfterBind(uv_work_t* req) { ...@@ -342,10 +341,10 @@ void Statement::Work_AfterBind(uv_work_t* req) {
} }
else { else {
// Fire callbacks. // Fire callbacks.
Local<Function> cb = NanNew(baton->callback); Local<Function> cb = Nan::New(baton->callback);
if (!cb.IsEmpty() && cb->IsFunction()) { if (!cb.IsEmpty() && cb->IsFunction()) {
Local<Value> argv[] = { NanNew(NanNull()) }; Local<Value> argv[] = { Nan::Null() };
TRY_CATCH_CALL(NanObjectWrapHandle(stmt), cb, 1, argv); TRY_CATCH_CALL(stmt->handle(), cb, 1, argv);
} }
} }
...@@ -355,16 +354,15 @@ void Statement::Work_AfterBind(uv_work_t* req) { ...@@ -355,16 +354,15 @@ void Statement::Work_AfterBind(uv_work_t* req) {
NAN_METHOD(Statement::Get) { NAN_METHOD(Statement::Get) {
NanScope(); Statement* stmt = Nan::ObjectWrap::Unwrap<Statement>(info.This());
Statement* stmt = ObjectWrap::Unwrap<Statement>(args.This());
Baton* baton = stmt->Bind<RowBaton>(args); Baton* baton = stmt->Bind<RowBaton>(info);
if (baton == NULL) { if (baton == NULL) {
return NanThrowError("Data type is not supported"); return Nan::ThrowError("Data type is not supported");
} }
else { else {
stmt->Schedule(Work_BeginGet, baton); stmt->Schedule(Work_BeginGet, baton);
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
} }
...@@ -397,7 +395,8 @@ void Statement::Work_Get(uv_work_t* req) { ...@@ -397,7 +395,8 @@ void Statement::Work_Get(uv_work_t* req) {
} }
void Statement::Work_AfterGet(uv_work_t* req) { void Statement::Work_AfterGet(uv_work_t* req) {
NanScope(); Nan::HandleScope scope;
STATEMENT_INIT(RowBaton); STATEMENT_INIT(RowBaton);
if (stmt->status != SQLITE_ROW && stmt->status != SQLITE_DONE) { if (stmt->status != SQLITE_ROW && stmt->status != SQLITE_DONE) {
...@@ -405,16 +404,16 @@ void Statement::Work_AfterGet(uv_work_t* req) { ...@@ -405,16 +404,16 @@ void Statement::Work_AfterGet(uv_work_t* req) {
} }
else { else {
// Fire callbacks. // Fire callbacks.
Local<Function> cb = NanNew(baton->callback); Local<Function> cb = Nan::New(baton->callback);
if (!cb.IsEmpty() && cb->IsFunction()) { if (!cb.IsEmpty() && cb->IsFunction()) {
if (stmt->status == SQLITE_ROW) { if (stmt->status == SQLITE_ROW) {
// Create the result array from the data we acquired. // Create the result array from the data we acquired.
Local<Value> argv[] = { NanNew(NanNull()), RowToJS(&baton->row) }; Local<Value> argv[] = { Nan::Null(), RowToJS(&baton->row) };
TRY_CATCH_CALL(NanObjectWrapHandle(stmt), cb, 2, argv); TRY_CATCH_CALL(stmt->handle(), cb, 2, argv);
} }
else { else {
Local<Value> argv[] = { NanNew(NanNull()) }; Local<Value> argv[] = { Nan::Null() };
TRY_CATCH_CALL(NanObjectWrapHandle(stmt), cb, 1, argv); TRY_CATCH_CALL(stmt->handle(), cb, 1, argv);
} }
} }
} }
...@@ -423,16 +422,15 @@ void Statement::Work_AfterGet(uv_work_t* req) { ...@@ -423,16 +422,15 @@ void Statement::Work_AfterGet(uv_work_t* req) {
} }
NAN_METHOD(Statement::Run) { NAN_METHOD(Statement::Run) {
NanScope(); Statement* stmt = Nan::ObjectWrap::Unwrap<Statement>(info.This());
Statement* stmt = ObjectWrap::Unwrap<Statement>(args.This());
Baton* baton = stmt->Bind<RunBaton>(args); Baton* baton = stmt->Bind<RunBaton>(info);
if (baton == NULL) { if (baton == NULL) {
return NanThrowError("Data type is not supported"); return Nan::ThrowError("Data type is not supported");
} }
else { else {
stmt->Schedule(Work_BeginRun, baton); stmt->Schedule(Work_BeginRun, baton);
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
} }
...@@ -467,7 +465,8 @@ void Statement::Work_Run(uv_work_t* req) { ...@@ -467,7 +465,8 @@ void Statement::Work_Run(uv_work_t* req) {
} }
void Statement::Work_AfterRun(uv_work_t* req) { void Statement::Work_AfterRun(uv_work_t* req) {
NanScope(); Nan::HandleScope scope;
STATEMENT_INIT(RunBaton); STATEMENT_INIT(RunBaton);
if (stmt->status != SQLITE_ROW && stmt->status != SQLITE_DONE) { if (stmt->status != SQLITE_ROW && stmt->status != SQLITE_DONE) {
...@@ -475,13 +474,13 @@ void Statement::Work_AfterRun(uv_work_t* req) { ...@@ -475,13 +474,13 @@ void Statement::Work_AfterRun(uv_work_t* req) {
} }
else { else {
// Fire callbacks. // Fire callbacks.
Local<Function> cb = NanNew(baton->callback); Local<Function> cb = Nan::New(baton->callback);
if (!cb.IsEmpty() && cb->IsFunction()) { if (!cb.IsEmpty() && cb->IsFunction()) {
NanObjectWrapHandle(stmt)->Set(NanNew("lastID"), NanNew<Number>(baton->inserted_id)); Nan::Set(stmt->handle(), Nan::New("lastID").ToLocalChecked(), Nan::New<Number>(baton->inserted_id));
NanObjectWrapHandle(stmt)->Set(NanNew("changes"), NanNew<Integer>(baton->changes)); Nan::Set(stmt->handle(), Nan::New("changes").ToLocalChecked(), Nan::New(baton->changes));
Local<Value> argv[] = { NanNew(NanNull()) }; Local<Value> argv[] = { Nan::Null() };
TRY_CATCH_CALL(NanObjectWrapHandle(stmt), cb, 1, argv); TRY_CATCH_CALL(stmt->handle(), cb, 1, argv);
} }
} }
...@@ -489,16 +488,15 @@ void Statement::Work_AfterRun(uv_work_t* req) { ...@@ -489,16 +488,15 @@ void Statement::Work_AfterRun(uv_work_t* req) {
} }
NAN_METHOD(Statement::All) { NAN_METHOD(Statement::All) {
NanScope(); Statement* stmt = Nan::ObjectWrap::Unwrap<Statement>(info.This());
Statement* stmt = ObjectWrap::Unwrap<Statement>(args.This());
Baton* baton = stmt->Bind<RowsBaton>(args); Baton* baton = stmt->Bind<RowsBaton>(info);
if (baton == NULL) { if (baton == NULL) {
return NanThrowError("Data type is not supported"); return Nan::ThrowError("Data type is not supported");
} }
else { else {
stmt->Schedule(Work_BeginAll, baton); stmt->Schedule(Work_BeginAll, baton);
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
} }
...@@ -533,7 +531,8 @@ void Statement::Work_All(uv_work_t* req) { ...@@ -533,7 +531,8 @@ void Statement::Work_All(uv_work_t* req) {
} }
void Statement::Work_AfterAll(uv_work_t* req) { void Statement::Work_AfterAll(uv_work_t* req) {
NanScope(); Nan::HandleScope scope;
STATEMENT_INIT(RowsBaton); STATEMENT_INIT(RowsBaton);
if (stmt->status != SQLITE_DONE) { if (stmt->status != SQLITE_DONE) {
...@@ -541,28 +540,28 @@ void Statement::Work_AfterAll(uv_work_t* req) { ...@@ -541,28 +540,28 @@ void Statement::Work_AfterAll(uv_work_t* req) {
} }
else { else {
// Fire callbacks. // Fire callbacks.
Local<Function> cb = NanNew(baton->callback); Local<Function> cb = Nan::New(baton->callback);
if (!cb.IsEmpty() && cb->IsFunction()) { if (!cb.IsEmpty() && cb->IsFunction()) {
if (baton->rows.size()) { if (baton->rows.size()) {
// Create the result array from the data we acquired. // Create the result array from the data we acquired.
Local<Array> result(NanNew<Array>(baton->rows.size())); Local<Array> result(Nan::New<Array>(baton->rows.size()));
Rows::const_iterator it = baton->rows.begin(); Rows::const_iterator it = baton->rows.begin();
Rows::const_iterator end = baton->rows.end(); Rows::const_iterator end = baton->rows.end();
for (int i = 0; it < end; ++it, i++) { for (int i = 0; it < end; ++it, i++) {
result->Set(i, RowToJS(*it)); Nan::Set(result, i, RowToJS(*it));
delete *it; delete *it;
} }
Local<Value> argv[] = { NanNew(NanNull()), result }; Local<Value> argv[] = { Nan::Null(), result };
TRY_CATCH_CALL(NanObjectWrapHandle(stmt), cb, 2, argv); TRY_CATCH_CALL(stmt->handle(), cb, 2, argv);
} }
else { else {
// There were no result rows. // There were no result rows.
Local<Value> argv[] = { Local<Value> argv[] = {
NanNew(NanNull()), Nan::Null(),
NanNew<Array>(0) Nan::New<Array>(0)
}; };
TRY_CATCH_CALL(NanObjectWrapHandle(stmt), cb, 2, argv); TRY_CATCH_CALL(stmt->handle(), cb, 2, argv);
} }
} }
} }
...@@ -571,24 +570,23 @@ void Statement::Work_AfterAll(uv_work_t* req) { ...@@ -571,24 +570,23 @@ void Statement::Work_AfterAll(uv_work_t* req) {
} }
NAN_METHOD(Statement::Each) { NAN_METHOD(Statement::Each) {
NanScope(); Statement* stmt = Nan::ObjectWrap::Unwrap<Statement>(info.This());
Statement* stmt = ObjectWrap::Unwrap<Statement>(args.This());
int last = args.Length(); int last = info.Length();
Local<Function> completed; Local<Function> completed;
if (last >= 2 && args[last - 1]->IsFunction() && args[last - 2]->IsFunction()) { if (last >= 2 && info[last - 1]->IsFunction() && info[last - 2]->IsFunction()) {
completed = Local<Function>::Cast(args[--last]); completed = Local<Function>::Cast(info[--last]);
} }
EachBaton* baton = stmt->Bind<EachBaton>(args, 0, last); EachBaton* baton = stmt->Bind<EachBaton>(info, 0, last);
if (baton == NULL) { if (baton == NULL) {
return NanThrowError("Data type is not supported"); return Nan::ThrowError("Data type is not supported");
} }
else { else {
NanAssignPersistent(baton->completed, completed); baton->completed.Reset(completed);
stmt->Schedule(Work_BeginEach, baton); stmt->Schedule(Work_BeginEach, baton);
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
} }
...@@ -597,8 +595,8 @@ void Statement::Work_BeginEach(Baton* baton) { ...@@ -597,8 +595,8 @@ void Statement::Work_BeginEach(Baton* baton) {
// the event loop. This prevents dangling events. // the event loop. This prevents dangling events.
EachBaton* each_baton = static_cast<EachBaton*>(baton); EachBaton* each_baton = static_cast<EachBaton*>(baton);
each_baton->async = new Async(each_baton->stmt, reinterpret_cast<uv_async_cb>(AsyncEach)); each_baton->async = new Async(each_baton->stmt, reinterpret_cast<uv_async_cb>(AsyncEach));
NanAssignPersistent(each_baton->async->item_cb, each_baton->callback); each_baton->async->item_cb.Reset(each_baton->callback);
NanAssignPersistent(each_baton->async->completed_cb, each_baton->completed); each_baton->async->completed_cb.Reset(each_baton->completed);
STATEMENT_BEGIN(Each); STATEMENT_BEGIN(Each);
} }
...@@ -654,7 +652,8 @@ void Statement::CloseCallback(uv_handle_t* handle) { ...@@ -654,7 +652,8 @@ void Statement::CloseCallback(uv_handle_t* handle) {
} }
void Statement::AsyncEach(uv_async_t* handle, int status) { void Statement::AsyncEach(uv_async_t* handle, int status) {
NanScope(); Nan::HandleScope scope;
Async* async = static_cast<Async*>(handle->data); Async* async = static_cast<Async*>(handle->data);
while (true) { while (true) {
...@@ -668,38 +667,39 @@ void Statement::AsyncEach(uv_async_t* handle, int status) { ...@@ -668,38 +667,39 @@ void Statement::AsyncEach(uv_async_t* handle, int status) {
break; break;
} }
Local<Function> cb = NanNew(async->item_cb); Local<Function> cb = Nan::New(async->item_cb);
if (!cb.IsEmpty() && cb->IsFunction()) { if (!cb.IsEmpty() && cb->IsFunction()) {
Local<Value> argv[2]; Local<Value> argv[2];
argv[0] = NanNew(NanNull()); argv[0] = Nan::Null();
Rows::const_iterator it = rows.begin(); Rows::const_iterator it = rows.begin();
Rows::const_iterator end = rows.end(); Rows::const_iterator end = rows.end();
for (int i = 0; it < end; ++it, i++) { for (int i = 0; it < end; ++it, i++) {
argv[1] = RowToJS(*it); argv[1] = RowToJS(*it);
async->retrieved++; async->retrieved++;
TRY_CATCH_CALL(NanObjectWrapHandle(async->stmt), cb, 2, argv); TRY_CATCH_CALL(async->stmt->handle(), cb, 2, argv);
delete *it; delete *it;
} }
} }
} }
Local<Function> cb = NanNew(async->completed_cb); Local<Function> cb = Nan::New(async->completed_cb);
if (async->completed) { if (async->completed) {
if (!cb.IsEmpty() && if (!cb.IsEmpty() &&
cb->IsFunction()) { cb->IsFunction()) {
Local<Value> argv[] = { Local<Value> argv[] = {
NanNew(NanNull()), Nan::Null(),
NanNew<Integer>(async->retrieved) Nan::New(async->retrieved)
}; };
TRY_CATCH_CALL(NanObjectWrapHandle(async->stmt), cb, 2, argv); TRY_CATCH_CALL(async->stmt->handle(), cb, 2, argv);
} }
uv_close((uv_handle_t*)handle, CloseCallback); uv_close(reinterpret_cast<uv_handle_t*>(handle), CloseCallback);
} }
} }
void Statement::Work_AfterEach(uv_work_t* req) { void Statement::Work_AfterEach(uv_work_t* req) {
NanScope(); Nan::HandleScope scope;
STATEMENT_INIT(EachBaton); STATEMENT_INIT(EachBaton);
if (stmt->status != SQLITE_DONE) { if (stmt->status != SQLITE_DONE) {
...@@ -710,15 +710,14 @@ void Statement::Work_AfterEach(uv_work_t* req) { ...@@ -710,15 +710,14 @@ void Statement::Work_AfterEach(uv_work_t* req) {
} }
NAN_METHOD(Statement::Reset) { NAN_METHOD(Statement::Reset) {
NanScope(); Statement* stmt = Nan::ObjectWrap::Unwrap<Statement>(info.This());
Statement* stmt = ObjectWrap::Unwrap<Statement>(args.This());
OPTIONAL_ARGUMENT_FUNCTION(0, callback); OPTIONAL_ARGUMENT_FUNCTION(0, callback);
Baton* baton = new Baton(stmt, callback); Baton* baton = new Baton(stmt, callback);
stmt->Schedule(Work_BeginReset, baton); stmt->Schedule(Work_BeginReset, baton);
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
void Statement::Work_BeginReset(Baton* baton) { void Statement::Work_BeginReset(Baton* baton) {
...@@ -733,23 +732,24 @@ void Statement::Work_Reset(uv_work_t* req) { ...@@ -733,23 +732,24 @@ void Statement::Work_Reset(uv_work_t* req) {
} }
void Statement::Work_AfterReset(uv_work_t* req) { void Statement::Work_AfterReset(uv_work_t* req) {
NanScope(); Nan::HandleScope scope;
STATEMENT_INIT(Baton); STATEMENT_INIT(Baton);
// Fire callbacks. // Fire callbacks.
Local<Function> cb = NanNew(baton->callback); Local<Function> cb = Nan::New(baton->callback);
if (!cb.IsEmpty() && cb->IsFunction()) { if (!cb.IsEmpty() && cb->IsFunction()) {
Local<Value> argv[] = { NanNew(NanNull()) }; Local<Value> argv[] = { Nan::Null() };
TRY_CATCH_CALL(NanObjectWrapHandle(stmt), cb, 1, argv); TRY_CATCH_CALL(stmt->handle(), cb, 1, argv);
} }
STATEMENT_END(); STATEMENT_END();
} }
Local<Object> Statement::RowToJS(Row* row) { Local<Object> Statement::RowToJS(Row* row) {
NanEscapableScope(); Nan::EscapableHandleScope scope;
Local<Object> result(NanNew<Object>()); Local<Object> result = Nan::New<Object>();
Row::const_iterator it = row->begin(); Row::const_iterator it = row->begin();
Row::const_iterator end = row->end(); Row::const_iterator end = row->end();
...@@ -760,28 +760,28 @@ Local<Object> Statement::RowToJS(Row* row) { ...@@ -760,28 +760,28 @@ Local<Object> Statement::RowToJS(Row* row) {
switch (field->type) { switch (field->type) {
case SQLITE_INTEGER: { case SQLITE_INTEGER: {
value = NanNew<Number>(((Values::Integer*)field)->value); value = Nan::New<Number>(((Values::Integer*)field)->value);
} break; } break;
case SQLITE_FLOAT: { case SQLITE_FLOAT: {
value = NanNew<Number>(((Values::Float*)field)->value); value = Nan::New<Number>(((Values::Float*)field)->value);
} break; } break;
case SQLITE_TEXT: { case SQLITE_TEXT: {
value = NanNew<String>(((Values::Text*)field)->value.c_str(), ((Values::Text*)field)->value.size()); value = Nan::New<String>(((Values::Text*)field)->value.c_str(), ((Values::Text*)field)->value.size()).ToLocalChecked();
} break; } break;
case SQLITE_BLOB: { case SQLITE_BLOB: {
value = NanNew(NanNewBufferHandle(((Values::Blob*)field)->value, ((Values::Blob*)field)->length)); value = Nan::CopyBuffer(((Values::Blob*)field)->value, ((Values::Blob*)field)->length).ToLocalChecked();
} break; } break;
case SQLITE_NULL: { case SQLITE_NULL: {
value = NanNew(NanNull()); value = Nan::Null();
} break; } break;
} }
result->Set(NanNew(field->name.c_str()), value); Nan::Set(result, Nan::New(field->name.c_str()).ToLocalChecked(), value);
DELETE_FIELD(field); DELETE_FIELD(field);
} }
return NanEscapeScope(result); return scope.Escape(result);
} }
void Statement::GetRow(Row* row, sqlite3_stmt* stmt) { void Statement::GetRow(Row* row, sqlite3_stmt* stmt) {
...@@ -817,24 +817,24 @@ void Statement::GetRow(Row* row, sqlite3_stmt* stmt) { ...@@ -817,24 +817,24 @@ void Statement::GetRow(Row* row, sqlite3_stmt* stmt) {
} }
NAN_METHOD(Statement::Finalize) { NAN_METHOD(Statement::Finalize) {
NanScope(); Statement* stmt = Nan::ObjectWrap::Unwrap<Statement>(info.This());
Statement* stmt = ObjectWrap::Unwrap<Statement>(args.This());
OPTIONAL_ARGUMENT_FUNCTION(0, callback); OPTIONAL_ARGUMENT_FUNCTION(0, callback);
Baton* baton = new Baton(stmt, callback); Baton* baton = new Baton(stmt, callback);
stmt->Schedule(Finalize, baton); stmt->Schedule(Finalize, baton);
NanReturnValue(NanObjectWrapHandle(stmt->db)); info.GetReturnValue().Set(stmt->db->handle());
} }
void Statement::Finalize(Baton* baton) { void Statement::Finalize(Baton* baton) {
NanScope(); Nan::HandleScope scope;
baton->stmt->Finalize(); baton->stmt->Finalize();
// Fire callback in case there was one. // Fire callback in case there was one.
Local<Function> cb = NanNew(baton->callback); Local<Function> cb = Nan::New(baton->callback);
if (!cb.IsEmpty() && cb->IsFunction()) { if (!cb.IsEmpty() && cb->IsFunction()) {
TRY_CATCH_CALL(NanObjectWrapHandle(baton->stmt), cb, 0, NULL); TRY_CATCH_CALL(baton->stmt->handle(), cb, 0, NULL);
} }
delete baton; delete baton;
...@@ -852,11 +852,12 @@ void Statement::Finalize() { ...@@ -852,11 +852,12 @@ void Statement::Finalize() {
} }
void Statement::CleanQueue() { void Statement::CleanQueue() {
NanScope(); Nan::HandleScope scope;
if (prepared && !queue.empty()) { if (prepared && !queue.empty()) {
// This statement has already been prepared and is now finalized. // This statement has already been prepared and is now finalized.
// Fire error for all remaining items in the queue. // Fire error for all remaining items in the queue.
EXCEPTION(NanNew<String>("Statement is already finalized"), SQLITE_MISUSE, exception); EXCEPTION(Nan::New<String>("Statement is already finalized").ToLocalChecked(), SQLITE_MISUSE, exception);
Local<Value> argv[] = { exception }; Local<Value> argv[] = { exception };
bool called = false; bool called = false;
...@@ -865,11 +866,11 @@ void Statement::CleanQueue() { ...@@ -865,11 +866,11 @@ void Statement::CleanQueue() {
Call* call = queue.front(); Call* call = queue.front();
queue.pop(); queue.pop();
Local<Function> cb = NanNew(call->baton->callback); Local<Function> cb = Nan::New(call->baton->callback);
if (prepared && !cb.IsEmpty() && if (prepared && !cb.IsEmpty() &&
cb->IsFunction()) { cb->IsFunction()) {
TRY_CATCH_CALL(NanObjectWrapHandle(this), cb, 1, argv); TRY_CATCH_CALL(handle(), cb, 1, argv);
called = true; called = true;
} }
...@@ -882,8 +883,8 @@ void Statement::CleanQueue() { ...@@ -882,8 +883,8 @@ void Statement::CleanQueue() {
// When we couldn't call a callback function, emit an error on the // When we couldn't call a callback function, emit an error on the
// Statement object. // Statement object.
if (!called) { if (!called) {
Local<Value> args[] = { NanNew("error"), exception }; Local<Value> info[] = { Nan::New("error").ToLocalChecked(), exception };
EMIT_EVENT(NanObjectWrapHandle(this), 2, args); EMIT_EVENT(handle(), 2, info);
} }
} }
else while (!queue.empty()) { else while (!queue.empty()) {
......
src/statement.h
#ifndef NODE_SQLITE3_SRC_STATEMENT_H #ifndef NODE_SQLITE3_SRC_STATEMENT_H
#define NODE_SQLITE3_SRC_STATEMENT_H #define NODE_SQLITE3_SRC_STATEMENT_H
#include <node.h>
#include "database.h" #include "database.h"
#include "threading.h" #include "threading.h"
...@@ -13,7 +12,7 @@ ...@@ -13,7 +12,7 @@
#include <vector> #include <vector>
#include <sqlite3.h> #include <sqlite3.h>
#include "nan.h" #include <nan.h>
using namespace v8; using namespace v8;
using namespace node; using namespace node;
...@@ -72,23 +71,23 @@ typedef Row Parameters; ...@@ -72,23 +71,23 @@ typedef Row Parameters;
class Statement : public ObjectWrap { class Statement : public Nan::ObjectWrap {
public: public:
static Persistent<FunctionTemplate> constructor_template; static Nan::Persistent<FunctionTemplate> constructor_template;
static void Init(Handle<Object> target); static NAN_MODULE_INIT(Init);
static NAN_METHOD(New); static NAN_METHOD(New);
struct Baton { struct Baton {
uv_work_t request; uv_work_t request;
Statement* stmt; Statement* stmt;
Persistent<Function> callback; Nan::Persistent<Function> callback;
Parameters parameters; Parameters parameters;
Baton(Statement* stmt_, Handle<Function> cb_) : stmt(stmt_) { Baton(Statement* stmt_, Local<Function> cb_) : stmt(stmt_) {
stmt->Ref(); stmt->Ref();
request.data = this; request.data = this;
NanAssignPersistent(callback, cb_); callback.Reset(cb_);
} }
virtual ~Baton() { virtual ~Baton() {
for (unsigned int i = 0; i < parameters.size(); i++) { for (unsigned int i = 0; i < parameters.size(); i++) {
...@@ -96,25 +95,25 @@ public: ...@@ -96,25 +95,25 @@ public:
DELETE_FIELD(field); DELETE_FIELD(field);
} }
stmt->Unref(); stmt->Unref();
NanDisposePersistent(callback); callback.Reset();
} }
}; };
struct RowBaton : Baton { struct RowBaton : Baton {
RowBaton(Statement* stmt_, Handle<Function> cb_) : RowBaton(Statement* stmt_, Local<Function> cb_) :
Baton(stmt_, cb_) {} Baton(stmt_, cb_) {}
Row row; Row row;
}; };
struct RunBaton : Baton { struct RunBaton : Baton {
RunBaton(Statement* stmt_, Handle<Function> cb_) : RunBaton(Statement* stmt_, Local<Function> cb_) :
Baton(stmt_, cb_), inserted_id(0), changes(0) {} Baton(stmt_, cb_), inserted_id(0), changes(0) {}
sqlite3_int64 inserted_id; sqlite3_int64 inserted_id;
int changes; int changes;
}; };
struct RowsBaton : Baton { struct RowsBaton : Baton {
RowsBaton(Statement* stmt_, Handle<Function> cb_) : RowsBaton(Statement* stmt_, Local<Function> cb_) :
Baton(stmt_, cb_) {} Baton(stmt_, cb_) {}
Rows rows; Rows rows;
}; };
...@@ -122,20 +121,20 @@ public: ...@@ -122,20 +121,20 @@ public:
struct Async; struct Async;
struct EachBaton : Baton { struct EachBaton : Baton {
Persistent<Function> completed; Nan::Persistent<Function> completed;
Async* async; // Isn't deleted when the baton is deleted. Async* async; // Isn't deleted when the baton is deleted.
EachBaton(Statement* stmt_, Handle<Function> cb_) : EachBaton(Statement* stmt_, Local<Function> cb_) :
Baton(stmt_, cb_) {} Baton(stmt_, cb_) {}
virtual ~EachBaton() { virtual ~EachBaton() {
NanDisposePersistent(completed); completed.Reset();
} }
}; };
struct PrepareBaton : Database::Baton { struct PrepareBaton : Database::Baton {
Statement* stmt; Statement* stmt;
std::string sql; std::string sql;
PrepareBaton(Database* db_, Handle<Function> cb_, Statement* stmt_) : PrepareBaton(Database* db_, Local<Function> cb_, Statement* stmt_) :
Baton(db_, cb_), stmt(stmt_) { Baton(db_, cb_), stmt(stmt_) {
stmt->Ref(); stmt->Ref();
} }
...@@ -167,8 +166,8 @@ public: ...@@ -167,8 +166,8 @@ public:
// Store the callbacks here because we don't have // Store the callbacks here because we don't have
// access to the baton in the async callback. // access to the baton in the async callback.
Persistent<Function> item_cb; Nan::Persistent<Function> item_cb;
Persistent<Function> completed_cb; Nan::Persistent<Function> completed_cb;
Async(Statement* st, uv_async_cb async_cb) : Async(Statement* st, uv_async_cb async_cb) :
stmt(st), completed(false), retrieved(0) { stmt(st), completed(false), retrieved(0) {
...@@ -180,13 +179,13 @@ public: ...@@ -180,13 +179,13 @@ public:
~Async() { ~Async() {
stmt->Unref(); stmt->Unref();
NanDisposePersistent(item_cb); item_cb.Reset();
NanDisposePersistent(completed_cb); completed_cb.Reset();
NODE_SQLITE3_MUTEX_DESTROY NODE_SQLITE3_MUTEX_DESTROY
} }
}; };
Statement(Database* db_) : ObjectWrap(), Statement(Database* db_) : Nan::ObjectWrap(),
db(db_), db(db_),
_handle(NULL), _handle(NULL),
status(SQLITE_OK), status(SQLITE_OK),
...@@ -220,8 +219,8 @@ protected: ...@@ -220,8 +219,8 @@ protected:
static void Finalize(Baton* baton); static void Finalize(Baton* baton);
void Finalize(); void Finalize();
template <class T> inline Values::Field* BindParameter(const Handle<Value> source, T pos); template <class T> inline Values::Field* BindParameter(const Local<Value> source, T pos);
template <class T> T* Bind(_NAN_METHOD_ARGS, int start = 0, int end = -1); template <class T> T* Bind(Nan::NAN_METHOD_ARGS_TYPE info, int start = 0, int end = -1);
bool Bind(const Parameters &parameters); bool Bind(const Parameters &parameters);
static void GetRow(Row* row, sqlite3_stmt* stmt); static void GetRow(Row* row, sqlite3_stmt* stmt);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment