Skip to content

N
node-sqlite3
Commit d5b59c31 by Benjamin Byholm
Options

Update for NAN 2.0

parent cc78b514
Showing with 86 additions and 86 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.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.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