Update to support the fully expanded, node-style error response pattern, specifically:

Aurynn Shaw · Aurynn Shaw · commit fa7aa22e08bf · 2010-10-27T21:07:02.000-07:00
db.query(query, args, function (error, results){});
diff --git a/demo.js b/demo.js
@@ -1,24 +1,31 @@
 var sys = require("sys");
 var pg = require("./lib/postgres-pure");
-pg.DEBUG=0;
+// pg.DEBUG=4;
 
-var db = new pg.connect("pgsql://test:12345@localhost:5432/pdxpugtest");
-// db.query("explain analyze select * from pg_class ;", function (rs, tx) {
-//     sys.puts(sys.inspect(rs));
-//     // tx.query("SELECT 2::int as querytest2", function (rs) {
-//     //     sys.puts(sys.inspect(rs));
-//     // });
-// });
+var db = new pg.connect("pgsql://test:12345@localhost:5432/returning_test");
+db.query("SELECT 1::querytest;", function (error, rs, tx) {
+    if (error) {
+        console.log("Error!");
+        sys.puts(error);
+        sys.puts(error.code);
+    }
+    else {
+        sys.puts(sys.inspect(rs));
+    }
+    
+    // tx.query("SELECT 2::int as querytest2", function (rs) {
+    //     sys.puts(sys.inspect(rs));
+    // });
+});
 
-db.prepare("INSERT INTO pdxpug (id) VALUES (?) RETURNING id", function (sth) {
-    sth.execute(1, function(rs) {
+db.prepare("INSERT INTO returning_test (val) VALUES (?) RETURNING id, val", function (sth) {
+    sth.execute("text value", function(e, rs) {
         if (rs === undefined) {
             console.log("No data.");
         }
         else {
             console.log(sys.inspect(rs));
         }
-        
     });
 });
 
diff --git a/lib/postgres-pure.js b/lib/postgres-pure.js
@@ -199,10 +199,18 @@ function parse_response(code, buffer) {
         break;
         case 'E':
             type = "ErrorResponse";
-            args = [{}];
+            var err = {};
+            // args = [{}];
             reader.multicstring().forEach(function (field) {
-              args[0][field[0]] = field.substr(1);
+              err[field[0]] = field.substr(1);
             });
+            // Now, convert it to a more useful object.
+            var obj = new Error();
+            obj.code = err['C'];
+            obj.message = err['M'];
+            obj.severity = err['S'];
+            
+            args = [obj];
             break;
         case 't':
             type = "ParameterDescription",
@@ -286,6 +294,14 @@ function parse_response(code, buffer) {
     return {type: type, args: args};
 }
 
+function Error () {
+    this.severity = "";
+    this.code = "";
+    this.message = "";
+    this.toString = function () {
+        return "[postgres.js] " + this.severity + ": " + this.message;
+    }
+}
 
 function message () {
     var self = this;
@@ -346,7 +362,7 @@ function message () {
 message.prototype = new process.EventEmitter;
 // message.prototype.constructor = message;
 
-function Query(sql, callback, errback) {
+function Query(sql, callback) {
     message.call(this);
     this.sql = sql;
     var q = this;
@@ -376,7 +392,7 @@ function Query(sql, callback, errback) {
             sys.debug("Callback: " + callback);
         }
         
-        callback(q.results);
+        callback(null, q.results);
     });
     q.toString = function () { return "Query: " + q.length};
     q.on("RowDescription", function (desc) {
@@ -385,6 +401,10 @@ function Query(sql, callback, errback) {
             sys.debug("Caught RowDescription message.");
         }
     });
+    q.on("ErrorResponse", function (e) {
+        callback(e);
+    });
+     
 }
 
 Query.prototype = new message;
@@ -492,6 +512,15 @@ function Prepared(sql, conn /*, use_named */) {
         }
     });
     
+    self.on("ErrorResponse", function (err) {
+        if (currExec != null) {
+            currExec.emit("ErrorResponse", err);
+        }
+        else {
+            self.error = e;
+        }
+    });
+    
     // self.empty = function () {
     //     return self.__proto__.empty.call(self);
     // }
@@ -594,7 +623,7 @@ function Prepared(sql, conn /*, use_named */) {
                 }
                 // Callback gets wrapped at the tx layer,
                 // so we know when this gets tripped.
-                callback(eP.results);
+                callback(null, eP.results);
             }
             else if (eP.noData === true) {
                 // Callback gets wrapped at the tx layer,
@@ -615,14 +644,14 @@ function Prepared(sql, conn /*, use_named */) {
         eP.on("newRow", function (row) {
             eP.results.push(row);
         });
+        eP.on("ErrorResponse", function (e) {
+            callback(e);
+        });
         if(exports.DEBUG > 0) {
             sys.debug("Pushing execute message to eB in Prepared.");
         }
         eB.push(eP);
     }
-    self.on("Error", function (err) {
-        
-    });
 }
 Prepared.prototype = new message();
 Prepared.prototype.constructor = Prepared;
@@ -1025,10 +1054,10 @@ function Connection(args) {
         var callback = args.pop();
         
         if (typeof(callback) === 'function') {
-            args.push(function (rs) {
+            args.push(function (err, rs) {
                 // do the implicit sync/commit here? 
                 // tx.commit();
-                callback(rs, tx); // So they have access to the transaction?
+                callback(err, rs, tx); // So they have access to the transaction?
             });
         }
         else {
@@ -1135,17 +1164,17 @@ function Connection(args) {
     
     Easy, and very nifty.
     */
-    conn.on('newListener', function (e, listener) {
-        if (e === 'String') {
-            // It's a string.
-            if (!(e in ['newListener'])) {
-                conn.notify(e, listener);
-            }
-        }
-    });
-    conn.notify = function (name) {
-        
-    }
+    // conn.on('newListener', function (e, listener) {
+    //     if (e === 'String') {
+    //         // It's a string.
+    //         if (!(e in ['newListener'])) {
+    //             conn.notify(e, listener);
+    //         }
+    //     }
+    // });
+    // conn.notify = function (name) {
+    //     
+    // }
 }
 Connection.prototype = new process.EventEmitter();
 
@@ -1217,11 +1246,11 @@ function Transaction (connection /*, params */) {
             // We have an otherwise normal query.
             // This does not require a normal Sync message
             // or any other such magic-ery.
-            var q = new Query(sql, function (rs) { 
+            var q = new Query(sql, function (err, rs) { 
                 if (exports.DEBUG > 3) {
                     sys.debug("RS is:" + sys.inspect(rs));
                 }
-                callback(rs);
+                callback(err, rs);
                 // callbackRun();
             });
             if (exports.DEBUG > 0) {
