wrap in namespace

src/database.cc

@@ -22,9 +22,7 @@
 #include "statement.h"
 #include "deferred_call.h"
 
-using namespace v8;
-using namespace node;
-
+using namespace node_sqlite3;
 
 Persistent<FunctionTemplate> Database::constructor_template;
 

src/database.h

@@ -27,6 +27,8 @@
 using namespace v8;
 using namespace node;
 
+namespace node_sqlite3 {
+
 class Database;
 
 
@@ -122,4 +124,6 @@ protected:
     std::queue<Call*> queue;
 };
 
+}
+
 #endif

src/sqlite3_bindings.cc

@@ -21,7 +21,8 @@
 #include "macros.h"
 #include "database.h"
 #include "statement.h"
-#include "demo.h"
+
+using namespace node_sqlite3;
 
 extern "C" void init (v8::Handle<Object> target) {
     Database::Init(target);

src/statement.cc

@@ -22,6 +22,8 @@
 #include "statement.h"
 #include "deferred_call.h"
 
+using namespace node_sqlite3;
+
 Persistent<FunctionTemplate> Statement::constructor_template;
 
 void Statement::Init(v8::Handle<Object> target) {
@@ -185,19 +187,19 @@ template <class T> T* Statement::Bind(const Arguments& args, int start) {
     for (int i = start; i < last; i++) {
         if (args[i]->IsString()) {
             String::Utf8Value val(args[i]->ToString());
-            baton->parameters.push_back(new Result::Text(val.length(), *val));
+            baton->parameters.push_back(new Data::Text(val.length(), *val));
         }
         else if (args[i]->IsInt32() || args[i]->IsUint32()) {
-            baton->parameters.push_back(new Result::Integer(args[i]->Int32Value()));
+            baton->parameters.push_back(new Data::Integer(args[i]->Int32Value()));
         }
         else if (args[i]->IsNumber()) {
-            baton->parameters.push_back(new Result::Float(args[i]->NumberValue()));
+            baton->parameters.push_back(new Data::Float(args[i]->NumberValue()));
         }
         else if (args[i]->IsBoolean()) {
-            baton->parameters.push_back(new Result::Integer(args[i]->BooleanValue() ? 1 : 0));
+            baton->parameters.push_back(new Data::Integer(args[i]->BooleanValue() ? 1 : 0));
         }
         else if (args[i]->IsNull()) {
-            baton->parameters.push_back(new Result::Null());
+            baton->parameters.push_back(new Data::Null());
         }
         else if (args[i]->IsUndefined()) {
             // Skip parameter position.
@@ -212,7 +214,7 @@ template <class T> T* Statement::Bind(const Arguments& args, int start) {
     return baton;
 }
 
-bool Statement::Bind(const Result::Row parameters) {
+bool Statement::Bind(const Data::Parameters parameters) {
     if (parameters.size() == 0) {
         return true;
     }
@@ -220,27 +222,27 @@ bool Statement::Bind(const Result::Row parameters) {
     sqlite3_reset(handle);
     sqlite3_clear_bindings(handle);
 
-    Result::Row::const_iterator it = parameters.begin();
-    Result::Row::const_iterator end = parameters.end();
+    Data::Parameters::const_iterator it = parameters.begin();
+    Data::Parameters::const_iterator end = parameters.end();
 
     // Note: bind parameters start with 1.
     for (int i = 1; it < end; it++, i++) {
-        Result::Field* field = *it;
+        Data::Field* field = *it;
         if (field == NULL) {
             continue;
         }
 
         switch (field->type) {
             case SQLITE_INTEGER: {
-                status = sqlite3_bind_int(handle, i, ((Result::Integer*)field)->value);
+                status = sqlite3_bind_int(handle, i, ((Data::Integer*)field)->value);
             } break;
             case SQLITE_FLOAT: {
-                status = sqlite3_bind_double(handle, i, ((Result::Float*)field)->value);
+                status = sqlite3_bind_double(handle, i, ((Data::Float*)field)->value);
             } break;
             case SQLITE_TEXT: {
                 status = sqlite3_bind_text(
-                    handle, i, ((Result::Text*)field)->value.c_str(),
-                    ((Result::Text*)field)->value.size(), SQLITE_TRANSIENT);
+                    handle, i, ((Data::Text*)field)->value.c_str(),
+                    ((Data::Text*)field)->value.size(), SQLITE_TRANSIENT);
             } break;
             // case SQLITE_BLOB: {
             //
@@ -487,24 +489,24 @@ int Statement::EIO_AfterReset(eio_req *req) {
     return 0;
 }
 
-Local<Array> Statement::RowToJS(Result::Row* row) {
+Local<Array> Statement::RowToJS(Data::Row* row) {
     Local<Array> result(Array::New(row->size()));
 
-    Result::Row::iterator it = row->begin();
+    Data::Row::iterator it = row->begin();
     for (int i = 0; it < row->end(); it++, i++) {
-        Result::Field* field = *it;
+        Data::Field* field = *it;
         switch (field->type) {
             case SQLITE_INTEGER: {
-                result->Set(i, Local<Integer>(Integer::New(((Result::Integer*)field)->value)));
+                result->Set(i, Local<Integer>(Integer::New(((Data::Integer*)field)->value)));
             } break;
             case SQLITE_FLOAT: {
-                result->Set(i, Local<Number>(Number::New(((Result::Float*)field)->value)));
+                result->Set(i, Local<Number>(Number::New(((Data::Float*)field)->value)));
             } break;
             case SQLITE_TEXT: {
-                result->Set(i, Local<String>(String::New(((Result::Text*)field)->value.c_str(), ((Result::Text*)field)->value.size())));
+                result->Set(i, Local<String>(String::New(((Data::Text*)field)->value.c_str(), ((Data::Text*)field)->value.size())));
             } break;
             // case SQLITE_BLOB: {
-            //     result->Set(i, Local<String>(String::New(((Result::Text*)field)->value.c_str())));
+            //     result->Set(i, Local<String>(String::New(((Data::Text*)field)->value.c_str())));
             // } break;
             case SQLITE_NULL: {
                 result->Set(i, Local<Value>::New(Null()));
@@ -515,30 +517,30 @@ Local<Array> Statement::RowToJS(Result::Row* row) {
     return result;
 }
 
-void Statement::GetRow(Result::Row* row, sqlite3_stmt* stmt) {
+void Statement::GetRow(Data::Row* row, sqlite3_stmt* stmt) {
     int rows = sqlite3_column_count(stmt);
 
     for (int i = 0; i < rows; i++) {
         int type = sqlite3_column_type(stmt, i);
         switch (type) {
             case SQLITE_INTEGER: {
-                row->push_back(new Result::Integer(sqlite3_column_int(stmt, i)));
+                row->push_back(new Data::Integer(sqlite3_column_int(stmt, i)));
             }   break;
             case SQLITE_FLOAT: {
-                row->push_back(new Result::Float(sqlite3_column_double(stmt, i)));
+                row->push_back(new Data::Float(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->push_back(new Result::Text(length, text));
+                row->push_back(new Data::Text(length, text));
             } break;
             case SQLITE_BLOB: {
                 const void* blob = sqlite3_column_blob(stmt, i);
                 int length = sqlite3_column_bytes(stmt, i);
-                row->push_back(new Result::Blob(length, blob));
+                row->push_back(new Data::Blob(length, blob));
             }   break;
             case SQLITE_NULL: {
-                row->push_back(new Result::Null());
+                row->push_back(new Data::Null());
             }   break;
             default:
                 assert(false);

src/statement.h

@@ -31,8 +31,9 @@
 using namespace v8;
 using namespace node;
 
+namespace node_sqlite3 {
 
-namespace Result {
+namespace Data {
     struct Field {
         Field(unsigned short _type = SQLITE_NULL) : type(_type) {}
         unsigned short type;
@@ -67,6 +68,8 @@ namespace Result {
 
     typedef Field Null;
     typedef std::vector<Field*> Row;
+    typedef Row Parameters;
+    typedef std::vector<Row*> Rows;
 }
 
 
@@ -82,7 +85,7 @@ public:
     static struct Baton {
         Statement* stmt;
         Persistent<Function> callback;
-        Result::Row parameters;
+        Data::Parameters parameters;
 
         Baton(Statement* stmt_, Handle<Function> cb_) : stmt(stmt_) {
             stmt->Ref();
@@ -99,7 +102,7 @@ public:
     static struct RowBaton : Baton {
         RowBaton(Statement* stmt_, Handle<Function> cb_) :
             Baton(stmt_, cb_) {}
-        Result::Row row;
+        Data::Row row;
     };
 
     static struct PrepareBaton : Database::Baton {
@@ -145,6 +148,7 @@ protected:
     EIO_DEFINITION(Bind);
     EIO_DEFINITION(Get);
     EIO_DEFINITION(Run);
+    EIO_DEFINITION(All);
     EIO_DEFINITION(Reset);
 
     static Handle<Value> Finalize(const Arguments& args);
@@ -152,10 +156,10 @@ protected:
     void Finalize();
 
     template <class T> T* Bind(const Arguments& args, int start = 0);
-    bool Bind(const Result::Row parameters);
+    bool Bind(const Data::Parameters parameters);
 
-    static void GetRow(Result::Row* row, sqlite3_stmt* stmt);
-    static Local<Array> RowToJS(Result::Row* row);
+    static void GetRow(Data::Row* row, sqlite3_stmt* stmt);
+    static Local<Array> RowToJS(Data::Row* row);
     void Schedule(EIO_Callback callback, Baton* baton);
     void Process();
     void CleanQueue();
@@ -174,4 +178,6 @@ protected:
     std::queue<Call*> queue;
 };
 
+}
+
 #endif

test/prepare.test.js

@@ -128,7 +128,7 @@ exports['test retrieving reset() function'] = function(beforeExit) {
     });
 };
 
-exports['test get() function binding'] = function(beforeExit) {
+exports['test multiple get() function binding'] = function(beforeExit) {
     var db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY);
 
     var retrieved = 0;
@@ -166,7 +166,29 @@ exports['test prepare() function binding'] = function(beforeExit) {
 
     var retrieved = 0;
 
-    db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num = ? AND txt = ?", 10, 'String 10').get(function(err, row) {
+    db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num = ? AND txt = ?", 10, 'String 10')
+      .get(function(err, row) {
+        if (err) throw err;
+        assert.equal(row[0], 'String 10');
+        assert.equal(row[1], 10);
+        assert.equal(row[2], 10 * Math.PI);
+        assert.equal(row[3], null);
+        retrieved++;
+    });
+
+    beforeExit(function() {
+        assert.equal(1, retrieved, "Didn't retrieve all rows");
+    });
+};
+
+
+exports['test get() function binding'] = function(beforeExit) {
+    var db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY);
+
+    var retrieved = 0;
+
+    db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num = ? AND txt = ?")
+      .get(10, 'String 10', function(err, row) {
         if (err) throw err;
         assert.equal(row[0], 'String 10');
         assert.equal(row[1], 10);