├── lib
    ├── supermarket.js
    └── store.js
├── test
    ├── multiple_dbs.js
    ├── queue.js
    ├── length.js
    ├── set_remove.js
    ├── multiple_get_set.js
    ├── get_set.js
    ├── multiple_set.js
    ├── foreach.js
    ├── all.js
    ├── filter.js
    └── json.js
├── package.json
└── readme.txt


/lib/supermarket.js:
--------------------------------------------------------------------------------
1 | module.exports = module.exports.Store = require('./store')
2 | 


--------------------------------------------------------------------------------
/test/multiple_dbs.js:
--------------------------------------------------------------------------------
 1 | var Store = require('supermarket');
 2 | 
 3 | exports['multiple set/get'] = function (assert) {
 4 |     var db1 = Store('/tmp/moo.db');
 5 |     var db2 = Store('/tmp/moo.db');
 6 | 
 7 |     db1.set('x', 5);
 8 |     db2.get('x', function (err, x) {
 9 |         assert.equal(x, 5);
10 |     });
11 | };
12 | 
13 | 


--------------------------------------------------------------------------------
/test/queue.js:
--------------------------------------------------------------------------------
 1 | var Store = require('supermarket');
 2 | 
 3 | exports['get/set'] = function (assert) {
 4 |     var file = '/tmp/' + Math.floor(Math.random() * 1e8) + '.db';
 5 |     
 6 |     var db = Store(file);
 7 | 
 8 |     db.set('moo', 5, function (sErr) {
 9 |         assert.ok(!sErr);
10 |     });
11 | 
12 |     db.get('moo', function (gErr, val, key) {
13 |         assert.equal(val, 5);
14 |         assert.equal(key, 'moo');
15 |     });
16 | };
17 | 


--------------------------------------------------------------------------------
/test/length.js:
--------------------------------------------------------------------------------
 1 | var Store = require('supermarket');
 2 | 
 3 | exports['length'] = function (assert) {
 4 |     Store(':memory:', function (err, db) {
 5 |         assert.ok(!err);
 6 | 
 7 |         range(0,100).forEach(function (i) {
 8 |             db.set(i, i, function (err, k, v) {
 9 |                 assert.ok(!err);
10 |                 if (v == 99) {
11 |                     db.length(function (err, len) {
12 |                         assert.ok(!err);
13 |                         assert.equal(len, 100);
14 |                     });
15 |                 }
16 |             });
17 |         });
18 |     });
19 | };
20 | 
21 | function range(i, j) {
22 |     var ret = [];
23 |     for (; i<j; i++) ret.push(i);
24 |     return ret;
25 | }
26 | 
27 | 


--------------------------------------------------------------------------------
/test/set_remove.js:
--------------------------------------------------------------------------------
 1 | var Store = require('supermarket');
 2 | 
 3 | exports['set/remove'] = function (assert) {
 4 |     var file = '/tmp/' + Math.floor(Math.random() * 1e8) + '.db';
 5 |     
 6 |     Store(file, function (error, db) {
 7 |         if (error) throw error;
 8 |         
 9 |         db.set('o_O', 50, function (sErr) {
10 |             assert.ok(!sErr);
11 |             db.remove('o_O', function (rErr) {
12 |                 assert.ok(!rErr);
13 |                 // no way to check if the key was removed for now
14 |                 // assert.ok(r);
15 |                 db.get('o_O', function (gErr, value) {
16 |                     assert.ok(!gErr);
17 |                     assert.equal(arguments.length, 0);
18 |                 });
19 |             });
20 |         });
21 |     });
22 | };
23 | 


--------------------------------------------------------------------------------
/test/multiple_get_set.js:
--------------------------------------------------------------------------------
 1 | var Store = require('supermarket');
 2 | 
 3 | exports['multiple set/get'] = function (assert) {
 4 |     var file = '/tmp/' + Math.floor(Math.random() * 1e8) + '.db';
 5 | 
 6 |     Store(file, function (error, db) {
 7 |         if (error) throw error;
 8 | 
 9 |         for (x in range(0,100)) {
10 |             var key = 'key' + (x).toString();
11 |             db.set(key, x, function (sErr) {
12 |                 assert.ok(!sErr);
13 |                 db.get(key, function (gErr, val) {
14 |                     assert.ok(!gErr);
15 |                     assert.equal(val, x);
16 |                 });
17 |             });
18 |         }
19 |     });
20 | };
21 | 
22 | function range(i, j) {
23 |     var ret = [];
24 |     for (; i<j; i++) ret.push(i);
25 |     return ret;
26 | }
27 | 
28 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "supermarket",
 3 |     "version": "1.1.3",
 4 |     "description": "A key/value store based on sqlite for node.js",
 5 |     "main": "./lib/supermarket.js",
 6 |     "modules" : {
 7 |         "index" : "./lib/supermarket.js"
 8 |     },
 9 |     "keywords": [
10 |         "sqlite",
11 |         "nosql",
12 |         "key value store",
13 |         "database"
14 |     ],
15 |     "author": {
16 |         "name": "Peteris Krumins",
17 |         "email": "peteris.krumins@gmail.com",
18 |         "web": "http://www.catonmat.net",
19 |         "twitter": "pkrumins"
20 |     }, 
21 |     "license": "MIT",
22 |     "repository": {
23 |         "type": "git",
24 |         "url": "http://github.com/pkrumins/node-supermarket.git"
25 |     }, 
26 |     "engines": {
27 |         "node": ">=0.1.93"
28 |     },
29 |     "dependencies" : {
30 |         "pksqlite": ">=0.0.3",
31 |         "lazy": ">=1.0.0"
32 |     }
33 | }
34 | 
35 | 


--------------------------------------------------------------------------------
/test/get_set.js:
--------------------------------------------------------------------------------
 1 | var Store = require('supermarket');
 2 | 
 3 | exports['get/set'] = function (assert) {
 4 |     var file = '/tmp/' + Math.floor(Math.random() * 1e8) + '.db';
 5 |     
 6 |     Store(file, function (error, db) {
 7 |         if (error) throw error;
 8 |         
 9 |         db.set('pkrumins', 5, function (sErr) {
10 |             assert.ok(!sErr);
11 |             db.get('pkrumins', function (gErr, value) {
12 |                 assert.ok(!gErr);
13 |                 assert.equal(value, 5);
14 |             });
15 |         });
16 |         
17 |         db.set('substack', 8, function (sErr) {
18 |             assert.ok(!sErr);
19 |             db.get('substack', function (gErr, value) {
20 |                 assert.ok(!gErr);
21 |                 assert.equal(value, 8);
22 |             });
23 |         });
24 | 
25 |         db.get('jesusabdullah', function (err, value) {
26 |             assert.ok(!err);
27 |             assert.equal(value, undefined);
28 |         });
29 |     });
30 | };
31 | 


--------------------------------------------------------------------------------
/test/multiple_set.js:
--------------------------------------------------------------------------------
 1 | var Store = require('supermarket');
 2 | var file = '/tmp/' + Math.floor(Math.random() * 1e8) + '.db';
 3 | 
 4 | exports['multiple set'] = function (assert) {
 5 |     Store(file, function (error, db) {
 6 |         if (error) throw error;
 7 | 
 8 |         range(0,100).forEach(function (x) {
 9 |             var key = 'key' + (x).toString();
10 |             db.set(key, x, function (sErr) {
11 |                 assert.ok(!sErr);
12 |                 if (x == 99) {
13 |                     range(0,100).forEach(function (y) {
14 |                         var key = 'key' + (y).toString();
15 |                         db.get(key, function (gErr, val) {
16 |                             assert.ok(!gErr);
17 |                             assert.equal(y, val);
18 |                         });
19 |                     });
20 |                 }
21 |             });
22 |         });
23 |     });
24 | };
25 | 
26 | function range(i, j) {
27 |     var ret = [];
28 |     for (; i<j; i++) ret.push(i);
29 |     return ret;
30 | }
31 | 
32 | 


--------------------------------------------------------------------------------
/test/foreach.js:
--------------------------------------------------------------------------------
 1 | var Store = require('supermarket');
 2 | 
 3 | exports['foreach'] = function (assert) {
 4 |     Store(':memory:', function (err, db) {
 5 |         assert.ok(!err);
 6 | 
 7 |         range(0,100).forEach(function (i) {
 8 |             var key = 'key' + (i).toString();
 9 |             db.set(key, i, function (err, k, v) {
10 |                 assert.ok(!err);
11 |                 if (v == 99) {
12 |                     test_foreach();
13 |                 }
14 |             });
15 |         });
16 | 
17 |         function test_foreach() {
18 |             var expectedSum = 99*(99+1)/2;
19 |             var runningSum = 0;
20 |             db
21 |                 .forEach(function (row) {
22 |                     runningSum += row.value;
23 |                 })
24 |                 .on('error', assert.fail)
25 |                 .on('end', function () {
26 |                     assert.equal(expectedSum, runningSum);
27 |                 })
28 |             ;
29 |         }
30 |     });
31 | }
32 | 
33 | function range(i, j) {
34 |     var ret = [];
35 |     for (; i<j; i++) ret.push(i);
36 |     return ret;
37 | }
38 | 
39 | 


--------------------------------------------------------------------------------
/test/all.js:
--------------------------------------------------------------------------------
 1 | var Store = require('supermarket');
 2 | 
 3 | exports['all'] = function (assert) {
 4 |     Store(':memory:', function (err, db) {
 5 |         assert.ok(!err);
 6 | 
 7 |         range(0,100).forEach(function (i) {
 8 |             var key = 'key' + (i).toString();
 9 |             db.set(key, i, function (err, k, v) {
10 |                 assert.ok(!err);
11 |                 if (v == 99) {
12 |                     test_all();
13 |                 }
14 |             });
15 |         });
16 | 
17 |         function test_all() {
18 |             var expectedKeys = [];
19 |             var expectedVals = [];
20 |             range(0,100).forEach(function (i) {
21 |                 expectedKeys.push('key' + (i).toString());
22 |                 expectedVals.push(i);
23 |             });
24 |             db.all(function (err, keys, vals) {
25 |                 function sorter(a,b) { return a-b }
26 |                 assert.eql(expectedKeys.sort(), keys.sort());
27 |                 assert.eql(expectedVals, vals.sort(sorter));
28 |             });
29 |         }
30 |     });
31 | }
32 | 
33 | function range(i, j) {
34 |     var ret = [];
35 |     for (; i<j; i++) ret.push(i);
36 |     return ret;
37 | }
38 | 
39 | 


--------------------------------------------------------------------------------
/test/filter.js:
--------------------------------------------------------------------------------
 1 | var Store = require('supermarket');
 2 | 
 3 | exports['filter'] = function (assert) {
 4 |     Store(':memory:', function (err, db) {
 5 |         assert.ok(!err);
 6 | 
 7 |         range(0,100).forEach(function (i) {
 8 |             var key = 'key' + (i).toString();
 9 |             db.set(key, i, function (err, k, v) {
10 |                 assert.ok(!err);
11 |                 if (v == 99) {
12 |                     test_evens();
13 |                 }
14 |             });
15 |         });
16 | 
17 |         function test_evens() {
18 |             var evens = [];
19 |             db.filter(
20 |                 function (key, val) { return val % 2 == 0 },
21 |                 function (err, key, val) {
22 |                     assert.ok(!err);
23 |                     evens.push(val);
24 |                 },
25 |                 function () {
26 |                     function sorter(a,b) { return a-b }
27 |                     assert.eql(
28 |                         evens.sort(sorter),
29 |                         range(0,100).filter(function (i) { return i % 2 == 0 })
30 |                     );
31 |                 }
32 |             );
33 |         }
34 |     });
35 | }
36 | 
37 | function range(i, j) {
38 |     var ret = [];
39 |     for (; i<j; i++) ret.push(i);
40 |     return ret;
41 | }
42 | 
43 | 


--------------------------------------------------------------------------------
/test/json.js:
--------------------------------------------------------------------------------
 1 | var Store = require('supermarket');
 2 | 
 3 | exports['json'] = function (assert) {
 4 |     var file = '/tmp/' + Math.floor(Math.random() * 1e8) + '.db';
 5 |     
 6 |     Store(
 7 |         { filename : file, json : true },
 8 |         function (error, db) {
 9 |             if (error) throw error;
10 |             
11 |             db.set('pkrumins', { age : 25, sex : 'male', location : 'latvia' },
12 |                 function (sErr) {
13 |                     assert.ok(!sErr);
14 |                     db.get('pkrumins', function (gErr, value) {
15 |                         assert.ok(!gErr);
16 |                         assert.equal(value.age, 25);
17 |                         assert.equal(value.sex, 'male');
18 |                         assert.equal(value.location, 'latvia');
19 |                     });
20 |                 }
21 |             );
22 |             
23 |             db.set('substack', { age : 22, sex : 'male',
24 |                 location : { country : 'usa', state : 'alaska' } }, function (sErr) {
25 |                     assert.ok(!sErr);
26 |                     db.get('substack', function (gErr, value) {
27 |                         assert.ok(!gErr);
28 |                         assert.equal(value.age, 22);
29 |                         assert.equal(value.sex, 'male');
30 |                         assert.equal(value.location.country, 'usa');
31 |                         assert.equal(value.location.state, 'alaska');
32 | 
33 |                         db
34 |                         .on('error', assert.fail)
35 |                         .forEach(function (row) {
36 |                             var key = row.key, val = row.value;
37 |                             assert.ok(key == 'pkrumins' || key == 'substack');
38 |                             assert.ok(val.age == 22 || val.age == 25);
39 |                             assert.ok(val.location == 'latvia' || val.location.country == 'usa');
40 | 
41 |                             db
42 |                                 .filter(function (row) {
43 |                                     return row.value.age <= 22;
44 |                                 })
45 |                                 .join(function (rows) {
46 |                                     assert.equal(rows.length, 1);
47 |                                     assert.equal(rows[0].key, 'substack');
48 |                                     assert.equal(rows[0].value.age, 22);
49 |                                     
50 |                                     db.all(function (aErr, keys, vals) {
51 |                                         assert.ok(!aErr);
52 |                                         assert.equal(keys.length, 2);
53 |                                         assert.equal(vals.length, 2);
54 |                                         assert.ok('pkrumins' == keys[0] || 'pkrumins' == keys[1]);
55 |                                         assert.ok('substack' == keys[0] || 'substack' == keys[1]);
56 |                                     });
57 |                                 })
58 |                             ;
59 |                         })
60 |                     });
61 |                 }
62 |             );
63 |         }
64 |     );
65 | };
66 | 


--------------------------------------------------------------------------------
/readme.txt:
--------------------------------------------------------------------------------
  1 | This is a key/value store based on sqlite for node.js that actually works.
  2 | 
  3 | It was written by Peteris Krumins (peter@catonmat.net).
  4 | His blog is at http://www.catonmat.net  --  good coders code, great reuse.
  5 | 
  6 | ------------------------------------------------------------------------------
  7 | 
  8 | It's very simple to use, first import the module:
  9 | 
 10 |     var Store = require('supermarket');
 11 | 
 12 | Then create a new instance of Store, passing in the database filename and
 13 | continuation that gets called when the database has been opened,
 14 | 
 15 |     Store('users.db', function (error, db) {
 16 |         // ... you can use db here ... check for error, too ...
 17 |     });
 18 | 
 19 | It provides .set and .get methods that are also continuations,
 20 | 
 21 |     Store('users.db', function (err, db) {
 22 |         db.set('pkrumins', 'cool dude', function (error) {
 23 |             // value 'pkrumins' is now set to 'cool dude'
 24 |             db.get('pkrumins', function (error, value, key) {
 25 |                 console.log(value); // cool dude
 26 |             });
 27 |         });
 28 |     });
 29 | 
 30 | If you wish to store JSON objects in the database, you may pass a dict with the
 31 | key 'json' set to true and the key 'filename' for file as the first argument to
 32 | Store,
 33 | 
 34 |     Store({ filename : 'objects.db', json : true },
 35 |         function (error, db) {
 36 |             // now any .set and .get operations will call JSON.stringify
 37 |             // and JSON.parse on values.
 38 |     	}
 39 |     );
 40 | 
 41 | ------------.
 42 | | Outdated: | The following docs are outdated as we just moved supermarket to node-lazy!
 43 | '-----------'
 44 | 
 45 | It also has .filter function that takes a predicate, callback and done function.
 46 | The .filter function calls callback on each row for which predicate is true.
 47 | After it's done filtering, it calls done function.
 48 | 
 49 | Here is an example:
 50 | 
 51 |     Store({ filename : 'users.db', json : true }, function (err, db) {
 52 |         var users = [];
 53 |         db.filter(
 54 |             function (user, userInfo) { //1//
 55 |                 return userInfo.age < 20
 56 |             },
 57 |             function (err, user, userInfo) { //2//
 58 |                 if (err) throw err;
 59 |                 users.push(userInfo);
 60 |             },
 61 |             function () { //3//
 62 |                 console.log("Users younger than 20:");
 63 |                 users.forEach(function (user) {
 64 |                     console.log(user.name);
 65 |                 });
 66 |             }
 67 |         );
 68 |     });
 69 | 
 70 | The filter function here takes the predicate function //1//, parses each record and
 71 | returns true if user's age is less than 20.
 72 | Now if the age is less than 20, filter calls callback function //2//, which adds each
 73 | user who's younger than 20 to users array.
 74 | Once filter has gone through all the records it calls done function //3//, which then
 75 | prints out all usernames of youngters.
 76 | 
 77 | Store also has .forEach method that iterates over all of its values,
 78 | 
 79 |     Store({ filename: 'users.db', json : true }, function (db) {
 80 |         db.forEach(
 81 |             function (err, key, val) {
 82 |                 if (err) throw err;
 83 |                 console.log("User " + key + " is " + val.age + " old.");
 84 |             },
 85 |             function () {
 86 |                 console.log("Done with all users.");
 87 |             }
 88 |         );
 89 |     });
 90 | 
 91 | forEach takes a callback and done function. Very similar to .filter.
 92 | 
 93 | It also has .all method that returns all keys and all values,
 94 | 
 95 |     Store('users.db', function (db) {
 96 |         db.all(function (err, users, userInfos) {
 97 |             // all users in users (keys)
 98 |             // all user infos in userInfos (values)
 99 |         });
100 |     });
101 | 
102 | 
103 | Another method is .length that returns the number of elements in the store,
104 | 
105 |     Store('users.db', function (db) {
106 |         db.length(function (len) {
107 |             console.log("There are " + len + " users in users.db database");
108 |         });
109 |    });
110 |     
111 | This library doesn't end here, our (my and substack's) is to create an object
112 | store, where you can just dump the whole js objects, and then restore them back,
113 | map, filter and fold on them, etc.
114 | 
115 | ------------------------------------------------------------------------------
116 | 
117 | Have fun storing those keys and values!
118 | 
119 | 
120 | Sincerely,
121 | Peteris Krumins
122 | http://www.catonmat.net
123 | 
124 | 


--------------------------------------------------------------------------------
/lib/store.js:
--------------------------------------------------------------------------------
  1 | var SQLite = require('pksqlite').Database;
  2 | var EventEmitter = require('events').EventEmitter;
  3 | var normalize = require('path').normalize;
  4 | var Lazy = require('lazy');
  5 | 
  6 | var openDbs = {};
  7 | 
  8 | module.exports = Store;
  9 | Store.prototype = new EventEmitter;
 10 | function Store(opts, cb) {
 11 |     if (!(this instanceof Store)) return new Store(opts, cb);
 12 |     if (cb === undefined) cb = function () {};
 13 |     var self = this;
 14 | 
 15 |     if (typeof opts === 'string') {
 16 |         var opts = {
 17 |             filename : opts,
 18 |             json : false
 19 |         }
 20 |     }
 21 | 
 22 |     if (opts.filename === undefined)
 23 |         throw new Error('Filename was not specified');
 24 | 
 25 |     if (opts.filename != ':memory:') {
 26 |         if (opts.filename[0] != '/')
 27 |             opts.filename = process.cwd() + '/' + opts.filename;
 28 | 
 29 |         opts.filename = normalize(opts.filename);
 30 |     } 
 31 |     
 32 |     opts.json = opts.json || false;
 33 | 
 34 |     var actionQueue = [];
 35 |     var ready = false;
 36 |  
 37 |     function queue(action, args) {
 38 |         actionQueue.push({ action : action, args : [].slice.call(args) });
 39 |     }
 40 | 
 41 |     function initStoreTable() {
 42 |         var hadRow = false;
 43 |         db.query(
 44 |             "SELECT * FROM SQLITE_MASTER WHERE type='table' AND name='store'",
 45 |             function (error, row) {
 46 |                 if (error) {
 47 |                     self.emit('error', error);
 48 |                     cb(error);
 49 |                     return;
 50 |                 }
 51 |                 if (row === undefined) {
 52 |                     if (hadRow) {
 53 |                         self.emit('ready');
 54 | 
 55 |                         cb(undefined, self);
 56 |                     }
 57 |                     else {
 58 |                         db.query(
 59 |                             "CREATE TABLE store (key TEXT UNIQUE, value BLOB)",
 60 |                             function (error) {
 61 |                                 if (error) {
 62 |                                     self.emit('error', error);
 63 |                                     cb(error);
 64 |                                 }
 65 |                                 else {
 66 |                                     self.emit('ready');
 67 |                                     cb(undefined, self);
 68 |                                 }
 69 |                             }
 70 |                         );
 71 |                     }
 72 |                 }
 73 |                 hadRow = true;
 74 |             }
 75 |         );
 76 |     }
 77 | 
 78 |     self.set = function (key, value, cb) {
 79 |         if (!ready) { 
 80 |             queue(self.set, arguments);
 81 |             return;
 82 |         }
 83 |         if (cb === undefined) cb = function () {}
 84 |         db.query(
 85 |             "INSERT OR REPLACE INTO store (key, value) VALUES (?, ?)",
 86 |             [key, opts.json ? JSON.stringify(value) : value],
 87 |             function (error) {
 88 |                 if (error) {
 89 |                     self.emit('error', error);
 90 |                     cb(error);
 91 |                 }
 92 |                 else {
 93 |                     cb(undefined, key, value);
 94 |                 }
 95 |             }
 96 |         );
 97 |     };
 98 | 
 99 |     self.get = function (key, cb) {
100 |         if (!ready) {
101 |             queue(self.get, arguments);
102 |             return;
103 |         }
104 |         if (cb === undefined) cb = function () {}
105 |         var hadRow = false;
106 |         db.query(
107 |             "SELECT value FROM store WHERE key = ?",
108 |             [key],
109 |             function (error, row) {
110 |                 if (error) {
111 |                     self.emit('error', error);
112 |                     cb(error);
113 |                 }
114 |                 else if (row === undefined) {
115 |                     if (hadRow) return;
116 |                     cb();
117 |                 }
118 |                 else {
119 |                     cb(undefined, opts.json ? JSON.parse(row.value) : row.value, key);
120 |                     hadRow = true;
121 |                 }
122 |             }
123 |         );
124 |     };
125 | 
126 |     self.remove = function (key, cb) {
127 |         if (!ready) {
128 |             queue(self.remove, arguments);
129 |             return;
130 |         }
131 |         if (cb === undefined) cb = function () {};
132 |         db.query(
133 |             "DELETE FROM store WHERE key = ?",
134 |             [key],
135 |             function (error) {
136 |                 if (error) {
137 |                     self.emit('error', error)
138 |                     cb(error);
139 |                 }
140 |                 else {
141 |                     // silly node-sql doesn't set rowsAffected
142 |                     // cb(undefined, r.rowsAffected == 1);
143 |                     cb(undefined);
144 |                 }
145 |             }
146 |         );
147 |     };
148 | 
149 |     self.length = function (cb) {
150 |         if (!ready) {
151 |             queue(self.length, arguments);
152 |             return;
153 |         }
154 |         if (cb === undefined) cb = function () {};
155 |         db.query(
156 |             "SELECT COUNT(*) as count FROM store",
157 |             function (error, row) {
158 |                 if (error) {
159 |                     self.emit('error', error);
160 |                     cb(error);
161 |                 }
162 |                 else if (row) {
163 |                     cb(undefined, row.count);
164 |                 }
165 |             }
166 |         );
167 |     }
168 |     
169 |     Object.keys(Lazy()).forEach(function (name) {
170 |         self[name] = function () {
171 |             var lazy = Lazy(self.stream());
172 |             return lazy[name].apply(lazy, arguments);
173 |         }
174 |     });
175 |     
176 |     self.stream = function (emitter) {
177 |         if (!emitter) emitter = new EventEmitter;
178 |         
179 |         if (!ready) {
180 |             queue(self.stream.bind(self,emitter), arguments);
181 |             return emitter;
182 |         }
183 |         
184 |         db.query(
185 |             "SELECT * FROM store",
186 |             function (error, row) {
187 |                 if (error) {
188 |                     emitter.emit('error', error);
189 |                     self.emit('error', error);
190 |                 }
191 |                 else if (row === undefined) {
192 |                     emitter.emit('end');
193 |                 }
194 |                 else {
195 |                     emitter.emit('data', {
196 |                         key : row.key,
197 |                         value : opts.json ? JSON.parse(row.value) : row.value,
198 |                     });
199 |                 }
200 |             }
201 |         );
202 |         
203 |         return emitter;
204 |     }
205 | 
206 |     self.all = function (cb) {
207 |         if (!ready) {
208 |             queue(self.all, arguments);
209 |             return;
210 |         }
211 |         self
212 |             .on('error', function (err) {
213 |                 self.emit('error', err);
214 |                 cb(err);
215 |             })
216 |             .join(function (rows) { cb(
217 |                 undefined,
218 |                 rows.map(function (r) { return r.key }),
219 |                 rows.map(function (r) { return r.value })
220 |             ) })
221 |         ;
222 |     };
223 | 
224 |     self.on('ready', function () {
225 |         ready = true;
226 |         actionQueue.forEach(function (action) {
227 |             action.action.apply(self, action.args);
228 |         });
229 |         delete actionQueue;
230 |     });
231 | 
232 |     if (openDbs[opts.filename]) {
233 |         var db = openDbs[opts.filename];
234 |         cb(undefined, db);
235 |         return;
236 |     }
237 |     else {
238 |         var db = new SQLite();
239 |         db.open(opts.filename, function (error) {
240 |             if (error) {
241 |                 self.emit('error', error);
242 |                 delete openDbs[opts.filename];
243 |                 cb(error);
244 |             }
245 |             initStoreTable();
246 |         });
247 |         if (opts.filename != ':memory:')
248 |             openDbs[opts.filename] = self;
249 |     }
250 | };
251 | 
252 | 


--------------------------------------------------------------------------------