garbage collect statements

src/database.cc

@@ -130,15 +130,13 @@ Handle<Value> Database::New(const Arguments& args) {
 void Database::EIO_BeginOpen(Baton* baton) {
     baton->db->Ref();
     ev_ref(EV_DEFAULT_UC);
-    fprintf(stderr, "Open started\n");
     eio_custom(EIO_Open, EIO_PRI_DEFAULT, EIO_AfterOpen, baton);
 }
 
 int Database::EIO_Open(eio_req *req) {
     OpenBaton* baton = static_cast<OpenBaton*>(req->data);
     Database* db = baton->db;
-    
-    fprintf(stderr, "Open performed\n");
+
     baton->status = sqlite3_open_v2(
         baton->filename.c_str(),
         &db->handle,
@@ -148,6 +146,7 @@ int Database::EIO_Open(eio_req *req) {
 
     if (baton->status != SQLITE_OK) {
         baton->message = std::string(sqlite3_errmsg(db->handle));
+        db->handle = NULL;
     }
 
     return 0;
@@ -182,10 +181,9 @@ int Database::EIO_AfterOpen(eio_req *req) {
     if (db->open) {
         Local<Value> args[] = { String::NewSymbol("open") };
         EMIT_EVENT(db->handle_, 1, args);
-        fprintf(stderr, "Open completed\n");
         Process(db);
     }
-    
+
     delete baton;
     return 0;
 }
@@ -210,7 +208,6 @@ void Database::EIO_BeginClose(Baton* baton) {
     assert(baton->db->open);
     assert(!baton->db->locked);
     assert(baton->db->pending == 0);
-    fprintf(stderr, "Close started\n");
     baton->db->locked = true;
     eio_custom(EIO_Close, EIO_PRI_DEFAULT, EIO_AfterClose, baton);
 }
@@ -219,7 +216,6 @@ int Database::EIO_Close(eio_req *req) {
     Baton* baton = static_cast<Baton*>(req->data);
     Database* db = baton->db;
 
-    fprintf(stderr, "Close performed\n");
     baton->status = sqlite3_close(db->handle);
 
     if (baton->status != SQLITE_OK) {
@@ -267,8 +263,6 @@ int Database::EIO_AfterClose(eio_req *req) {
     }
 
     delete baton;
-    
-    fprintf(stderr, "Close completed\n");
 
     return 0;
 }
@@ -288,7 +282,7 @@ void Database::Wrap(Handle<Object> handle) {
 void Database::Destruct(Persistent<Value> value, void *data) {
     Database* db = static_cast<Database*>(data);
     if (db->handle) {
-        eio_custom(EIO_Close, EIO_PRI_DEFAULT, EIO_AfterDestruct, db);
+        eio_custom(EIO_Destruct, EIO_PRI_DEFAULT, EIO_AfterDestruct, db);
         ev_ref(EV_DEFAULT_UC);
     }
     else {
@@ -296,6 +290,15 @@ void Database::Destruct(Persistent<Value> value, void *data) {
     }
 }
 
+int Database::EIO_Destruct(eio_req *req) {
+    Database* db = static_cast<Database*>(req->data);
+
+    sqlite3_close(db->handle);
+    db->handle = NULL;
+
+    return 0;
+}
+
 int Database::EIO_AfterDestruct(eio_req *req) {
     Database* db = static_cast<Database*>(req->data);
     ev_unref(EV_DEFAULT_UC);

src/statement.cc

@@ -100,8 +100,7 @@ Handle<Value> Statement::New(const Arguments& args) {
 void Statement::EIO_BeginPrepare(Baton* baton) {
     assert(baton->db->open);
     assert(!baton->db->locked);
-    baton->db->pending++;
-    static_cast<PrepareBaton*>(baton)->stmt->Ref();
+    // static_cast<PrepareBaton*>(baton)->stmt->Ref();
     ev_ref(EV_DEFAULT_UC);
     fprintf(stderr, "Prepare started\n");
     eio_custom(EIO_Prepare, EIO_PRI_DEFAULT, EIO_AfterPrepare, baton);
@@ -110,24 +109,26 @@ void Statement::EIO_BeginPrepare(Baton* baton) {
 int Statement::EIO_Prepare(eio_req *req) {
     PrepareBaton* baton = static_cast<PrepareBaton*>(req->data);
     Database* db = baton->db;
+    Statement* stmt = baton->stmt;
+
+    sqlite3_mutex* mtx = sqlite3_db_mutex(db->handle);
+    sqlite3_mutex_enter(mtx);
+
+    baton->status = sqlite3_prepare_v2(
+        db->handle,
+        baton->sql.c_str(),
+        baton->sql.size(),
+        &stmt->handle,
+        NULL
+    );
+
+    if (baton->status != SQLITE_OK) {
+        baton->message = std::string(sqlite3_errmsg(db->handle));
+        stmt->handle = NULL;
+    }
+
+    sqlite3_mutex_leave(mtx);
 
-    fprintf(stderr, "Prepare performed\n");
-    // baton->status = sqlite3_prepare16_v2(
-    //     db->handle,
-    //     const void *zSql,       /* SQL statement, UTF-16 encoded */
-    //     int nByte,              /* Maximum length of zSql in bytes. */
-    //     sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
-    //     const void **pzTail     /* OUT: Pointer to unused portion of zSql */
-    // );
-    //
-    // baton->status = sqlite3_close(db->handle);
-    //
-    // if (baton->status != SQLITE_OK) {
-    //     baton->message = std::string(sqlite3_errmsg(db->handle));
-    // }
-    // else {
-    //     db->handle = NULL;
-    // }
     return 0;
 }
 
@@ -139,7 +140,6 @@ int Statement::EIO_AfterPrepare(eio_req *req) {
 
     stmt->Unref();
     ev_unref(EV_DEFAULT_UC);
-    db->pending--;
 
     // Local<Value> argv[1];
     // if (baton->status != SQLITE_OK) {
@@ -169,10 +169,53 @@ int Statement::EIO_AfterPrepare(eio_req *req) {
     // }
 
     fprintf(stderr, "Prepare completed\n");
-    
+
+    // V8::AdjustAmountOfExternalAllocatedMemory(10000000);
+
     Database::Process(db);
 
     delete baton;
 
     return 0;
 }
+
+/**
+ * Override this so that we can properly finalize the statement when it
+ * gets garbage collected.
+ */
+void Statement::Wrap(Handle<Object> handle) {
+    assert(handle_.IsEmpty());
+    assert(handle->InternalFieldCount() > 0);
+    handle_ = Persistent<Object>::New(handle);
+    handle_->SetPointerInInternalField(0, this);
+    handle_.MakeWeak(this, Destruct);
+}
+
+void Statement::Destruct(Persistent<Value> value, void *data) {
+    Statement* stmt = static_cast<Statement*>(data);
+    fprintf(stderr, "Auto-Finalizing handle started\n");
+    if (stmt->handle) {
+        eio_custom(EIO_Destruct, EIO_PRI_DEFAULT, EIO_AfterDestruct, stmt);
+        ev_ref(EV_DEFAULT_UC);
+    }
+    else {
+        delete stmt;
+    }
+}
+
+int Statement::EIO_Destruct(eio_req *req) {
+    Statement* stmt = static_cast<Statement*>(req->data);
+
+    fprintf(stderr, "Auto-Finalizing handle\n");
+    sqlite3_finalize(stmt->handle);
+    stmt->handle = NULL;
+
+    return 0;
+}
+
+int Statement::EIO_AfterDestruct(eio_req *req) {
+    Statement* stmt = static_cast<Statement*>(req->data);
+    ev_unref(EV_DEFAULT_UC);
+    delete stmt;
+    return 0;
+}

src/statement.h

@@ -46,10 +46,14 @@ public:
 
     Statement(Database* db_) : EventEmitter() {
         db = db_;
+        db->pending++;
         db->Ref();
     }
 
     ~Statement() {
+        fprintf(stderr, "Deleted Statement\n");
+        db->pending--;
+        Database::Process(db);
         db->Unref();
     }
 
@@ -58,7 +62,12 @@ protected:
     static int EIO_Prepare(eio_req *req);
     static int EIO_AfterPrepare(eio_req *req);
 
-private:
+    void Wrap (Handle<Object> handle);
+    static void Destruct (Persistent<Value> value, void *data);
+    static int EIO_Destruct(eio_req *req);
+    static int EIO_AfterDestruct(eio_req *req);
+
+protected:
     Database* db;
 
     sqlite3_stmt* handle;