mirror of
https://github.com/NodeBB/NodeBB.git
synced 2025-11-13 01:15:47 +01:00
Async refactor in place (#7736)
* feat: allow both callback&and await
* feat: ignore async key
* feat: callbackify and promisify in same file
* Revert "feat: callbackify and promisify in same file"
This reverts commit cea206a9b8.
* feat: no need to store .callbackify
* feat: change getTopics to async
* feat: remove .async
* fix: byScore
* feat: rewrite topics/index and social with async/await
* fix: rewrite topics/data.js
fix issue with async.waterfall, only pass result if its not undefined
* feat: add callbackify to redis/psql
* feat: psql use await
* fix: redis 🌋
* feat: less returns
* feat: more await rewrite
* fix: redis tests
* feat: convert sortedSetAdd
rewrite psql transaction to async/await
* feat: 🐶
* feat: test
* feat: log client and query
* feat: log bind
* feat: more logs
* feat: more logs
* feat: check perform
* feat: dont callbackify transaction
* feat: remove logs
* fix: main functions
* feat: more logs
* fix: increment
* fix: rename
* feat: remove cls
* fix: remove console.log
* feat: add deprecation message to .async usage
* feat: update more dbal methods
* fix: redis :voodoo:
* feat: fix redis zrem, convert setObject
* feat: upgrade getObject methods
* fix: psql getObjectField
* fix: redis tests
* feat: getObjectKeys
* feat: getObjectValues
* feat: isObjectField
* fix: add missing return
* feat: delObjectField
* feat: incrObjectField
* fix: add missing await
* feat: remove exposed helpers
* feat: list methods
* feat: flush/empty
* feat: delete
* fix: redis delete all
* feat: get/set
* feat: incr/rename
* feat: type
* feat: expire
* feat: setAdd
* feat: setRemove
* feat: isSetMember
* feat: getSetMembers
* feat: setCount, setRemoveRandom
* feat: zcard,zcount
* feat: sortedSetRank
* feat: isSortedSetMember
* feat: zincrby
* feat: sortedSetLex
* feat: processSortedSet
* fix: add mising await
* feat: debug psql
* fix: psql test
* fix: test
* fix: another test
* fix: test fix
* fix: psql tests
* feat: remove logs
* feat: user arrow func
use builtin async promises
* feat: topic bookmarks
* feat: topic.delete
* feat: topic.restore
* feat: topics.purge
* feat: merge
* feat: suggested
* feat: topics/user.js
* feat: topics modules
* feat: topics/follow
* fix: deprecation msg
* feat: fork
* feat: topics/posts
* feat: sorted/recent
* feat: topic/teaser
* feat: topics/tools
* feat: topics/unread
* feat: add back node versions
disable deprecation notice
wrap async controllers in try/catch
* feat: use db directly
* feat: promisify in place
* fix: redis/psql
* feat: deprecation message
logs for psql
* feat: more logs
* feat: more logs
* feat: logs again
* feat: more logs
* fix: call release
* feat: restore travis, remove logs
* fix: loops
* feat: remove .async. usage
This commit is contained in:
Barış Soner Uşaklı
committed by
GitHub
GitHub
parent
43ce5f8af3
commit
805dcd7ca2
@@ -59,9 +59,6 @@ mongoModule.questions = [
|
||||
},
|
||||
];
|
||||
|
||||
mongoModule.helpers = mongoModule.helpers || {};
|
||||
mongoModule.helpers.mongo = require('./mongo/helpers');
|
||||
|
||||
mongoModule.getConnectionString = function (mongo) {
|
||||
mongo = mongo || nconf.get('mongo');
|
||||
var usernamePassword = '';
|
||||
@@ -130,7 +127,6 @@ mongoModule.init = function (callback) {
|
||||
require('./mongo/transaction')(db, mongoModule);
|
||||
|
||||
mongoModule.async = require('../promisify')(mongoModule, ['client', 'sessionStore']);
|
||||
|
||||
callback();
|
||||
});
|
||||
};
|
||||
|
||||
@@ -1,86 +1,73 @@
|
||||
'use strict';
|
||||
|
||||
var async = require('async');
|
||||
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.mongo;
|
||||
var helpers = require('./helpers');
|
||||
|
||||
var _ = require('lodash');
|
||||
const cache = require('../cache').create('mongo');
|
||||
|
||||
module.objectCache = cache;
|
||||
|
||||
module.setObject = function (key, data, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.setObject = async function (key, data) {
|
||||
if (!key || !data) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
const writeData = helpers.serializeData(data);
|
||||
db.collection('objects').updateOne({ _key: key }, { $set: writeData }, { upsert: true, w: 1 }, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
cache.delObjectCache(key);
|
||||
callback();
|
||||
});
|
||||
await db.collection('objects').updateOne({ _key: key }, { $set: writeData }, { upsert: true, w: 1 });
|
||||
cache.delObjectCache(key);
|
||||
};
|
||||
|
||||
module.setObjectField = function (key, field, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.setObjectField = async function (key, field, value) {
|
||||
if (!field) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
var data = {};
|
||||
data[field] = value;
|
||||
module.setObject(key, data, callback);
|
||||
await module.setObject(key, data);
|
||||
};
|
||||
|
||||
module.getObject = function (key, callback) {
|
||||
module.getObject = async function (key) {
|
||||
if (!key) {
|
||||
return setImmediate(callback, null, null);
|
||||
return null;
|
||||
}
|
||||
|
||||
module.getObjects([key], function (err, data) {
|
||||
callback(err, data && data.length ? data[0] : null);
|
||||
});
|
||||
const data = await module.getObjects([key]);
|
||||
return data && data.length ? data[0] : null;
|
||||
};
|
||||
|
||||
module.getObjects = function (keys, callback) {
|
||||
module.getObjectsFields(keys, [], callback);
|
||||
module.getObjects = async function (keys) {
|
||||
return await module.getObjectsFields(keys, []);
|
||||
};
|
||||
|
||||
module.getObjectField = function (key, field, callback) {
|
||||
module.getObjectField = async function (key, field) {
|
||||
if (!key) {
|
||||
return setImmediate(callback, null, null);
|
||||
return null;
|
||||
}
|
||||
const cachedData = {};
|
||||
cache.getUnCachedKeys([key], cachedData);
|
||||
if (cachedData[key]) {
|
||||
return setImmediate(callback, null, cachedData[key].hasOwnProperty(field) ? cachedData[key][field] : null);
|
||||
return cachedData[key].hasOwnProperty(field) ? cachedData[key][field] : null;
|
||||
}
|
||||
field = helpers.fieldToString(field);
|
||||
db.collection('objects').findOne({ _key: key }, { projection: { _id: 0, [field]: 1 } }, function (err, item) {
|
||||
if (err || !item) {
|
||||
return callback(err, null);
|
||||
}
|
||||
callback(null, item.hasOwnProperty(field) ? item[field] : null);
|
||||
});
|
||||
};
|
||||
|
||||
module.getObjectFields = function (key, fields, callback) {
|
||||
if (!key) {
|
||||
return setImmediate(callback, null, null);
|
||||
const item = await db.collection('objects').findOne({ _key: key }, { projection: { _id: 0, [field]: 1 } });
|
||||
if (!item) {
|
||||
return null;
|
||||
}
|
||||
module.getObjectsFields([key], fields, function (err, data) {
|
||||
callback(err, data ? data[0] : null);
|
||||
});
|
||||
return item.hasOwnProperty(field) ? item[field] : null;
|
||||
};
|
||||
|
||||
module.getObjectsFields = function (keys, fields, callback) {
|
||||
module.getObjectFields = async function (key, fields) {
|
||||
if (!key) {
|
||||
return null;
|
||||
}
|
||||
const data = await module.getObjectsFields([key], fields);
|
||||
return data ? data[0] : null;
|
||||
};
|
||||
|
||||
module.getObjectsFields = async function (keys, fields) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return setImmediate(callback, null, []);
|
||||
return [];
|
||||
}
|
||||
const cachedData = {};
|
||||
function returnData() {
|
||||
@@ -97,104 +84,72 @@ module.exports = function (db, module) {
|
||||
return result;
|
||||
});
|
||||
|
||||
callback(null, mapped);
|
||||
return mapped;
|
||||
}
|
||||
|
||||
const unCachedKeys = cache.getUnCachedKeys(keys, cachedData);
|
||||
if (!unCachedKeys.length) {
|
||||
return process.nextTick(returnData);
|
||||
return returnData();
|
||||
}
|
||||
|
||||
var query = { _key: { $in: unCachedKeys } };
|
||||
if (unCachedKeys.length === 1) {
|
||||
query._key = unCachedKeys[0];
|
||||
}
|
||||
db.collection('objects').find(query, { projection: { _id: 0 } }).toArray(function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
data = data.map(helpers.deserializeData);
|
||||
var map = helpers.toMap(data);
|
||||
unCachedKeys.forEach(function (key) {
|
||||
cachedData[key] = map[key] || null;
|
||||
cache.set(key, cachedData[key]);
|
||||
});
|
||||
let data = await db.collection('objects').find(query, { projection: { _id: 0 } }).toArray();
|
||||
|
||||
returnData();
|
||||
data = data.map(helpers.deserializeData);
|
||||
var map = helpers.toMap(data);
|
||||
unCachedKeys.forEach(function (key) {
|
||||
cachedData[key] = map[key] || null;
|
||||
cache.set(key, cachedData[key]);
|
||||
});
|
||||
|
||||
return returnData();
|
||||
};
|
||||
|
||||
module.getObjectKeys = function (key, callback) {
|
||||
module.getObject(key, function (err, data) {
|
||||
callback(err, data ? Object.keys(data) : []);
|
||||
});
|
||||
module.getObjectKeys = async function (key) {
|
||||
const data = await module.getObject(key);
|
||||
return data ? Object.keys(data) : [];
|
||||
};
|
||||
|
||||
module.getObjectValues = function (key, callback) {
|
||||
module.getObject(key, function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
var values = [];
|
||||
for (var key in data) {
|
||||
if (data && data.hasOwnProperty(key)) {
|
||||
values.push(data[key]);
|
||||
}
|
||||
}
|
||||
callback(null, values);
|
||||
});
|
||||
module.getObjectValues = async function (key) {
|
||||
const data = await module.getObject(key);
|
||||
return data ? Object.values(data) : [];
|
||||
};
|
||||
|
||||
module.isObjectField = function (key, field, callback) {
|
||||
module.isObjectField = async function (key, field) {
|
||||
const data = await module.isObjectFields(key, [field]);
|
||||
return Array.isArray(data) && data.length ? data[0] : false;
|
||||
};
|
||||
|
||||
module.isObjectFields = async function (key, fields) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
}
|
||||
var data = {};
|
||||
field = helpers.fieldToString(field);
|
||||
data[field] = 1;
|
||||
db.collection('objects').findOne({ _key: key }, { projection: data }, function (err, item) {
|
||||
callback(err, !!item && item[field] !== undefined && item[field] !== null);
|
||||
});
|
||||
};
|
||||
|
||||
module.isObjectFields = function (key, fields, callback) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
var data = {};
|
||||
const data = {};
|
||||
fields.forEach(function (field) {
|
||||
field = helpers.fieldToString(field);
|
||||
data[field] = 1;
|
||||
});
|
||||
|
||||
db.collection('objects').findOne({ _key: key }, { projection: data }, function (err, item) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
var results = [];
|
||||
|
||||
fields.forEach(function (field, index) {
|
||||
results[index] = !!item && item[field] !== undefined && item[field] !== null;
|
||||
});
|
||||
|
||||
callback(null, results);
|
||||
});
|
||||
const item = await db.collection('objects').findOne({ _key: key }, { projection: data });
|
||||
const results = fields.map(f => !!item && item[f] !== undefined && item[f] !== null);
|
||||
return results;
|
||||
};
|
||||
|
||||
module.deleteObjectField = function (key, field, callback) {
|
||||
module.deleteObjectFields(key, [field], callback);
|
||||
module.deleteObjectField = async function (key, field) {
|
||||
await module.deleteObjectFields(key, [field]);
|
||||
};
|
||||
|
||||
module.deleteObjectFields = function (key, fields, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.deleteObjectFields = async function (key, fields) {
|
||||
if (!key || !Array.isArray(fields) || !fields.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
fields = fields.filter(Boolean);
|
||||
if (!fields.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
var data = {};
|
||||
@@ -203,68 +158,41 @@ module.exports = function (db, module) {
|
||||
data[field] = '';
|
||||
});
|
||||
|
||||
db.collection('objects').updateOne({ _key: key }, { $unset: data }, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
cache.delObjectCache(key);
|
||||
callback();
|
||||
});
|
||||
await db.collection('objects').updateOne({ _key: key }, { $unset: data });
|
||||
cache.delObjectCache(key);
|
||||
};
|
||||
|
||||
module.incrObjectField = function (key, field, callback) {
|
||||
module.incrObjectFieldBy(key, field, 1, callback);
|
||||
module.incrObjectField = async function (key, field) {
|
||||
return await module.incrObjectFieldBy(key, field, 1);
|
||||
};
|
||||
|
||||
module.decrObjectField = function (key, field, callback) {
|
||||
module.incrObjectFieldBy(key, field, -1, callback);
|
||||
module.decrObjectField = async function (key, field) {
|
||||
return await module.incrObjectFieldBy(key, field, -1);
|
||||
};
|
||||
|
||||
module.incrObjectFieldBy = function (key, field, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.incrObjectFieldBy = async function (key, field, value) {
|
||||
value = parseInt(value, 10);
|
||||
if (!key || isNaN(value)) {
|
||||
return callback(null, null);
|
||||
return null;
|
||||
}
|
||||
|
||||
var data = {};
|
||||
var increment = {};
|
||||
field = helpers.fieldToString(field);
|
||||
data[field] = value;
|
||||
increment[field] = value;
|
||||
|
||||
if (Array.isArray(key)) {
|
||||
var bulk = db.collection('objects').initializeUnorderedBulkOp();
|
||||
key.forEach(function (key) {
|
||||
bulk.find({ _key: key }).upsert().update({ $inc: data });
|
||||
bulk.find({ _key: key }).upsert().update({ $inc: increment });
|
||||
});
|
||||
|
||||
async.waterfall([
|
||||
function (next) {
|
||||
bulk.execute(function (err) {
|
||||
next(err);
|
||||
});
|
||||
},
|
||||
function (next) {
|
||||
cache.delObjectCache(key);
|
||||
|
||||
module.getObjectsFields(key, [field], next);
|
||||
},
|
||||
function (data, next) {
|
||||
data = data.map(function (data) {
|
||||
return data && data[field];
|
||||
});
|
||||
next(null, data);
|
||||
},
|
||||
], callback);
|
||||
return;
|
||||
await bulk.execute();
|
||||
cache.delObjectCache(key);
|
||||
const result = await module.getObjectsFields(key, [field]);
|
||||
return result.map(data => data && data[field]);
|
||||
}
|
||||
|
||||
|
||||
db.collection('objects').findOneAndUpdate({ _key: key }, { $inc: data }, { returnOriginal: false, upsert: true }, function (err, result) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
cache.delObjectCache(key);
|
||||
callback(null, result && result.value ? result.value[field] : null);
|
||||
});
|
||||
const result = await db.collection('objects').findOneAndUpdate({ _key: key }, { $inc: increment }, { returnOriginal: false, upsert: true });
|
||||
cache.delObjectCache(key);
|
||||
return result && result.value ? result.value[field] : null;
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,112 +1,75 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.mongo;
|
||||
|
||||
module.listPrepend = function (key, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
var helpers = require('./helpers');
|
||||
|
||||
module.listPrepend = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
module.isObjectField(key, 'array', function (err, exists) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (exists) {
|
||||
db.collection('objects').updateOne({ _key: key }, { $push: { array: { $each: [value], $position: 0 } } }, { upsert: true, w: 1 }, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
} else {
|
||||
module.listAppend(key, value, callback);
|
||||
}
|
||||
});
|
||||
const exists = await module.isObjectField(key, 'array');
|
||||
if (exists) {
|
||||
await db.collection('objects').updateOne({ _key: key }, { $push: { array: { $each: [value], $position: 0 } } }, { upsert: true, w: 1 });
|
||||
} else {
|
||||
await module.listAppend(key, value);
|
||||
}
|
||||
};
|
||||
|
||||
module.listAppend = function (key, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.listAppend = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
db.collection('objects').updateOne({ _key: key }, { $push: { array: value } }, { upsert: true, w: 1 }, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await db.collection('objects').updateOne({ _key: key }, { $push: { array: value } }, { upsert: true, w: 1 });
|
||||
};
|
||||
|
||||
module.listRemoveLast = function (key, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.listRemoveLast = async function (key) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
module.getListRange(key, -1, -1, function (err, value) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
db.collection('objects').updateOne({ _key: key }, { $pop: { array: 1 } }, function (err) {
|
||||
callback(err, (value && value.length) ? value[0] : null);
|
||||
});
|
||||
});
|
||||
const value = await module.getListRange(key, -1, -1);
|
||||
db.collection('objects').updateOne({ _key: key }, { $pop: { array: 1 } });
|
||||
return (value && value.length) ? value[0] : null;
|
||||
};
|
||||
|
||||
module.listRemoveAll = function (key, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.listRemoveAll = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
db.collection('objects').updateOne({ _key: key }, { $pull: { array: value } }, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await db.collection('objects').updateOne({ _key: key }, { $pull: { array: value } });
|
||||
};
|
||||
|
||||
module.listTrim = function (key, start, stop, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.listTrim = async function (key, start, stop) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
module.getListRange(key, start, stop, function (err, value) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
db.collection('objects').updateOne({ _key: key }, { $set: { array: value } }, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
});
|
||||
const value = await module.getListRange(key, start, stop);
|
||||
await db.collection('objects').updateOne({ _key: key }, { $set: { array: value } });
|
||||
};
|
||||
|
||||
module.getListRange = function (key, start, stop, callback) {
|
||||
module.getListRange = async function (key, start, stop) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
db.collection('objects').findOne({ _key: key }, { array: 1 }, function (err, data) {
|
||||
if (err || !(data && data.array)) {
|
||||
return callback(err, []);
|
||||
}
|
||||
const data = await db.collection('objects').findOne({ _key: key }, { array: 1 });
|
||||
if (!(data && data.array)) {
|
||||
return [];
|
||||
}
|
||||
|
||||
if (stop === -1) {
|
||||
data.array = data.array.slice(start);
|
||||
} else {
|
||||
data.array = data.array.slice(start, stop + 1);
|
||||
}
|
||||
callback(null, data.array);
|
||||
});
|
||||
return data.array.slice(start, stop !== -1 ? stop + 1 : undefined);
|
||||
};
|
||||
|
||||
module.listLength = function (key, callback) {
|
||||
db.collection('objects').aggregate([
|
||||
module.listLength = async function (key) {
|
||||
const result = await db.collection('objects').aggregate([
|
||||
{ $match: { _key: key } },
|
||||
{ $project: { count: { $size: '$array' } } },
|
||||
]).toArray(function (err, result) {
|
||||
callback(err, Array.isArray(result) && result.length && result[0].count);
|
||||
});
|
||||
]).toArray();
|
||||
return Array.isArray(result) && result.length && result[0].count;
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,170 +1,121 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.mongo;
|
||||
|
||||
module.flushdb = function (callback) {
|
||||
callback = callback || helpers.noop;
|
||||
db.dropDatabase(function (err) {
|
||||
callback(err);
|
||||
});
|
||||
module.flushdb = async function () {
|
||||
await db.dropDatabase();
|
||||
};
|
||||
|
||||
module.emptydb = function (callback) {
|
||||
callback = callback || helpers.noop;
|
||||
db.collection('objects').deleteMany({}, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
module.objectCache.resetObjectCache();
|
||||
callback();
|
||||
});
|
||||
module.emptydb = async function () {
|
||||
await db.collection('objects').deleteMany({});
|
||||
module.objectCache.resetObjectCache();
|
||||
};
|
||||
|
||||
module.exists = function (key, callback) {
|
||||
module.exists = async function (key) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
if (Array.isArray(key)) {
|
||||
db.collection('objects').find({ _key: { $in: key } }).toArray(function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
var map = {};
|
||||
data.forEach(function (item) {
|
||||
map[item._key] = true;
|
||||
});
|
||||
|
||||
callback(null, key.map(key => !!map[key]));
|
||||
});
|
||||
} else {
|
||||
db.collection('objects').findOne({ _key: key }, function (err, item) {
|
||||
callback(err, item !== undefined && item !== null);
|
||||
const data = await db.collection('objects').find({ _key: { $in: key } }).toArray();
|
||||
var map = {};
|
||||
data.forEach(function (item) {
|
||||
map[item._key] = true;
|
||||
});
|
||||
|
||||
return key.map(key => !!map[key]);
|
||||
}
|
||||
const item = await db.collection('objects').findOne({ _key: key });
|
||||
return item !== undefined && item !== null;
|
||||
};
|
||||
|
||||
module.delete = function (key, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.delete = async function (key) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
db.collection('objects').deleteMany({ _key: key }, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
module.objectCache.delObjectCache(key);
|
||||
callback();
|
||||
});
|
||||
await db.collection('objects').deleteMany({ _key: key });
|
||||
module.objectCache.delObjectCache(key);
|
||||
};
|
||||
|
||||
module.deleteAll = function (keys, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.deleteAll = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
db.collection('objects').deleteMany({ _key: { $in: keys } }, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
module.objectCache.delObjectCache(keys);
|
||||
|
||||
callback(null);
|
||||
});
|
||||
await db.collection('objects').deleteMany({ _key: { $in: keys } });
|
||||
module.objectCache.delObjectCache(keys);
|
||||
};
|
||||
|
||||
module.get = function (key, callback) {
|
||||
module.get = async function (key) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
db.collection('objects').findOne({ _key: key }, { projection: { _id: 0 } }, function (err, objectData) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
const objectData = await db.collection('objects').findOne({ _key: key }, { projection: { _id: 0 } });
|
||||
|
||||
// fallback to old field name 'value' for backwards compatibility #6340
|
||||
var value = null;
|
||||
if (objectData) {
|
||||
if (objectData.hasOwnProperty('data')) {
|
||||
value = objectData.data;
|
||||
} else if (objectData.hasOwnProperty('value')) {
|
||||
value = objectData.value;
|
||||
}
|
||||
// fallback to old field name 'value' for backwards compatibility #6340
|
||||
var value = null;
|
||||
if (objectData) {
|
||||
if (objectData.hasOwnProperty('data')) {
|
||||
value = objectData.data;
|
||||
} else if (objectData.hasOwnProperty('value')) {
|
||||
value = objectData.value;
|
||||
}
|
||||
}
|
||||
callback(null, value);
|
||||
});
|
||||
}
|
||||
return value;
|
||||
};
|
||||
|
||||
module.set = function (key, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.set = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
var data = { data: value };
|
||||
module.setObject(key, data, callback);
|
||||
await module.setObject(key, data);
|
||||
};
|
||||
|
||||
module.increment = function (key, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.increment = async function (key) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
db.collection('objects').findOneAndUpdate({ _key: key }, { $inc: { data: 1 } }, { returnOriginal: false, upsert: true }, function (err, result) {
|
||||
callback(err, result && result.value ? result.value.data : null);
|
||||
});
|
||||
const result = await db.collection('objects').findOneAndUpdate({ _key: key }, { $inc: { data: 1 } }, { returnOriginal: false, upsert: true });
|
||||
return result && result.value ? result.value.data : null;
|
||||
};
|
||||
|
||||
module.rename = function (oldKey, newKey, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
db.collection('objects').updateMany({ _key: oldKey }, { $set: { _key: newKey } }, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
module.objectCache.delObjectCache(oldKey);
|
||||
module.objectCache.delObjectCache(newKey);
|
||||
callback();
|
||||
});
|
||||
module.rename = async function (oldKey, newKey) {
|
||||
await db.collection('objects').updateMany({ _key: oldKey }, { $set: { _key: newKey } });
|
||||
module.objectCache.delObjectCache([oldKey, newKey]);
|
||||
};
|
||||
|
||||
module.type = function (key, callback) {
|
||||
db.collection('objects').findOne({ _key: key }, function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
if (!data) {
|
||||
return callback(null, null);
|
||||
}
|
||||
delete data.expireAt;
|
||||
var keys = Object.keys(data);
|
||||
if (keys.length === 4 && data.hasOwnProperty('_key') && data.hasOwnProperty('score') && data.hasOwnProperty('value')) {
|
||||
return callback(null, 'zset');
|
||||
} else if (keys.length === 3 && data.hasOwnProperty('_key') && data.hasOwnProperty('members')) {
|
||||
return callback(null, 'set');
|
||||
} else if (keys.length === 3 && data.hasOwnProperty('_key') && data.hasOwnProperty('array')) {
|
||||
return callback(null, 'list');
|
||||
} else if (keys.length === 3 && data.hasOwnProperty('_key') && data.hasOwnProperty('data')) {
|
||||
return callback(null, 'string');
|
||||
}
|
||||
callback(null, 'hash');
|
||||
});
|
||||
module.type = async function (key) {
|
||||
const data = await db.collection('objects').findOne({ _key: key });
|
||||
if (!data) {
|
||||
return null;
|
||||
}
|
||||
delete data.expireAt;
|
||||
var keys = Object.keys(data);
|
||||
if (keys.length === 4 && data.hasOwnProperty('_key') && data.hasOwnProperty('score') && data.hasOwnProperty('value')) {
|
||||
return 'zset';
|
||||
} else if (keys.length === 3 && data.hasOwnProperty('_key') && data.hasOwnProperty('members')) {
|
||||
return 'set';
|
||||
} else if (keys.length === 3 && data.hasOwnProperty('_key') && data.hasOwnProperty('array')) {
|
||||
return 'list';
|
||||
} else if (keys.length === 3 && data.hasOwnProperty('_key') && data.hasOwnProperty('data')) {
|
||||
return 'string';
|
||||
}
|
||||
return 'hash';
|
||||
};
|
||||
|
||||
module.expire = function (key, seconds, callback) {
|
||||
module.expireAt(key, Math.round(Date.now() / 1000) + seconds, callback);
|
||||
module.expire = async function (key, seconds) {
|
||||
await module.expireAt(key, Math.round(Date.now() / 1000) + seconds);
|
||||
};
|
||||
|
||||
module.expireAt = function (key, timestamp, callback) {
|
||||
module.setObjectField(key, 'expireAt', new Date(timestamp * 1000), callback);
|
||||
module.expireAt = async function (key, timestamp) {
|
||||
await module.setObjectField(key, 'expireAt', new Date(timestamp * 1000));
|
||||
};
|
||||
|
||||
module.pexpire = function (key, ms, callback) {
|
||||
module.pexpireAt(key, Date.now() + parseInt(ms, 10), callback);
|
||||
module.pexpire = async function (key, ms) {
|
||||
await module.pexpireAt(key, Date.now() + parseInt(ms, 10));
|
||||
};
|
||||
|
||||
module.pexpireAt = function (key, timestamp, callback) {
|
||||
module.pexpireAt = async function (key, timestamp) {
|
||||
timestamp = Math.min(timestamp, 8640000000000000);
|
||||
module.setObjectField(key, 'expireAt', new Date(timestamp), callback);
|
||||
await module.setObjectField(key, 'expireAt', new Date(timestamp));
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,19 +1,16 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.mongo;
|
||||
var helpers = require('./helpers');
|
||||
|
||||
module.setAdd = function (key, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.setAdd = async function (key, value) {
|
||||
if (!Array.isArray(value)) {
|
||||
value = [value];
|
||||
}
|
||||
|
||||
value.forEach(function (element, index, array) {
|
||||
array[index] = helpers.valueToString(element);
|
||||
});
|
||||
value = value.map(v => helpers.valueToString(v));
|
||||
|
||||
db.collection('objects').updateOne({
|
||||
await db.collection('objects').updateOne({
|
||||
_key: key,
|
||||
}, {
|
||||
$addToSet: {
|
||||
@@ -24,25 +21,19 @@ module.exports = function (db, module) {
|
||||
}, {
|
||||
upsert: true,
|
||||
w: 1,
|
||||
}, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
};
|
||||
|
||||
module.setsAdd = function (keys, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.setsAdd = async function (keys, value) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
if (!Array.isArray(value)) {
|
||||
value = [value];
|
||||
}
|
||||
|
||||
value.forEach(function (element, index, array) {
|
||||
array[index] = helpers.valueToString(element);
|
||||
});
|
||||
value = value.map(v => helpers.valueToString(v));
|
||||
|
||||
var bulk = db.collection('objects').initializeUnorderedBulkOp();
|
||||
|
||||
@@ -53,168 +44,118 @@ module.exports = function (db, module) {
|
||||
},
|
||||
} });
|
||||
}
|
||||
|
||||
bulk.execute(function (err) {
|
||||
try {
|
||||
await bulk.execute();
|
||||
} catch (err) {
|
||||
if (err && err.message.startsWith('E11000 duplicate key error')) {
|
||||
return process.nextTick(module.setsAdd, keys, value, callback);
|
||||
return await module.setsAdd(keys, value);
|
||||
}
|
||||
callback(err);
|
||||
});
|
||||
throw err;
|
||||
}
|
||||
};
|
||||
|
||||
module.setRemove = function (key, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.setRemove = async function (key, value) {
|
||||
if (!Array.isArray(value)) {
|
||||
value = [value];
|
||||
}
|
||||
|
||||
value.forEach(function (element, index, array) {
|
||||
array[index] = helpers.valueToString(element);
|
||||
});
|
||||
value = value.map(v => helpers.valueToString(v));
|
||||
|
||||
if (Array.isArray(key)) {
|
||||
db.collection('objects').updateMany({ _key: { $in: key } }, { $pullAll: { members: value } }, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
} else {
|
||||
db.collection('objects').updateOne({ _key: key }, { $pullAll: { members: value } }, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
}
|
||||
await db.collection('objects').updateMany({ _key: Array.isArray(key) ? { $in: key } : key }, { $pullAll: { members: value } });
|
||||
};
|
||||
|
||||
module.setsRemove = function (keys, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.setsRemove = async function (keys, value) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
db.collection('objects').updateMany({ _key: { $in: keys } }, { $pull: { members: value } }, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await db.collection('objects').updateMany({ _key: { $in: keys } }, { $pull: { members: value } });
|
||||
};
|
||||
|
||||
module.isSetMember = function (key, value, callback) {
|
||||
module.isSetMember = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback(null, false);
|
||||
return false;
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
db.collection('objects').findOne({ _key: key, members: value }, { projection: { _id: 0, members: 0 } }, function (err, item) {
|
||||
callback(err, item !== null && item !== undefined);
|
||||
});
|
||||
const item = await db.collection('objects').findOne({ _key: key, members: value }, { projection: { _id: 0, members: 0 } });
|
||||
return item !== null && item !== undefined;
|
||||
};
|
||||
|
||||
module.isSetMembers = function (key, values, callback) {
|
||||
module.isSetMembers = async function (key, values) {
|
||||
if (!key || !Array.isArray(values) || !values.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
values = values.map(v => helpers.valueToString(v));
|
||||
|
||||
for (var i = 0; i < values.length; i += 1) {
|
||||
values[i] = helpers.valueToString(values[i]);
|
||||
}
|
||||
|
||||
db.collection('objects').findOne({ _key: key }, { projection: { _id: 0, _key: 0 } }, function (err, items) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
const membersSet = new Set(items && Array.isArray(items.members) ? items.members : []);
|
||||
values = values.map(value => membersSet.has(value));
|
||||
callback(null, values);
|
||||
});
|
||||
const result = await db.collection('objects').findOne({ _key: key }, { projection: { _id: 0, _key: 0 } });
|
||||
const membersSet = new Set(result && Array.isArray(result.members) ? result.members : []);
|
||||
return values.map(v => membersSet.has(v));
|
||||
};
|
||||
|
||||
module.isMemberOfSets = function (sets, value, callback) {
|
||||
module.isMemberOfSets = async function (sets, value) {
|
||||
if (!Array.isArray(sets) || !sets.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
db.collection('objects').find({ _key: { $in: sets }, members: value }, { projection: { _id: 0, members: 0 } }).toArray(function (err, result) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
var map = {};
|
||||
result.forEach(function (item) {
|
||||
map[item._key] = true;
|
||||
});
|
||||
const result = await db.collection('objects').find({ _key: { $in: sets }, members: value }, { projection: { _id: 0, members: 0 } }).toArray();
|
||||
|
||||
result = sets.map(function (set) {
|
||||
return !!map[set];
|
||||
});
|
||||
|
||||
callback(null, result);
|
||||
var map = {};
|
||||
result.forEach(function (item) {
|
||||
map[item._key] = true;
|
||||
});
|
||||
|
||||
return sets.map(set => !!map[set]);
|
||||
};
|
||||
|
||||
module.getSetMembers = function (key, callback) {
|
||||
module.getSetMembers = async function (key) {
|
||||
if (!key) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
|
||||
db.collection('objects').findOne({ _key: key }, { projection: { _id: 0, _key: 0 } }, function (err, data) {
|
||||
callback(err, data ? data.members : []);
|
||||
});
|
||||
const data = await db.collection('objects').findOne({ _key: key }, { projection: { _id: 0, _key: 0 } });
|
||||
return data ? data.members : [];
|
||||
};
|
||||
|
||||
module.getSetsMembers = function (keys, callback) {
|
||||
module.getSetsMembers = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
db.collection('objects').find({ _key: { $in: keys } }, { projection: { _id: 0 } }).toArray(function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
const data = await db.collection('objects').find({ _key: { $in: keys } }, { projection: { _id: 0 } }).toArray();
|
||||
|
||||
var sets = {};
|
||||
data.forEach(function (set) {
|
||||
sets[set._key] = set.members || [];
|
||||
});
|
||||
|
||||
var returnData = new Array(keys.length);
|
||||
for (var i = 0; i < keys.length; i += 1) {
|
||||
returnData[i] = sets[keys[i]] || [];
|
||||
}
|
||||
callback(null, returnData);
|
||||
var sets = {};
|
||||
data.forEach(function (set) {
|
||||
sets[set._key] = set.members || [];
|
||||
});
|
||||
|
||||
return keys.map(k => sets[k] || []);
|
||||
};
|
||||
|
||||
module.setCount = function (key, callback) {
|
||||
module.setCount = async function (key) {
|
||||
if (!key) {
|
||||
return callback(null, 0);
|
||||
return 0;
|
||||
}
|
||||
db.collection('objects').findOne({ _key: key }, { projection: { _id: 0 } }, function (err, data) {
|
||||
callback(err, data ? data.members.length : 0);
|
||||
});
|
||||
const data = await db.collection('objects').findOne({ _key: key }, { projection: { _id: 0 } });
|
||||
return data ? data.members.length : 0;
|
||||
};
|
||||
|
||||
module.setsCount = function (keys, callback) {
|
||||
module.getSetsMembers(keys, function (err, setsMembers) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
var counts = setsMembers.map(function (members) {
|
||||
return (members && members.length) || 0;
|
||||
});
|
||||
callback(null, counts);
|
||||
});
|
||||
module.setsCount = async function (keys) {
|
||||
const setsMembers = await module.getSetsMembers(keys);
|
||||
var counts = setsMembers.map(members => (members && members.length) || 0);
|
||||
return counts;
|
||||
};
|
||||
|
||||
module.setRemoveRandom = function (key, callback) {
|
||||
callback = callback || function () {};
|
||||
db.collection('objects').findOne({ _key: key }, function (err, data) {
|
||||
if (err || !data) {
|
||||
return callback(err);
|
||||
}
|
||||
module.setRemoveRandom = async function (key) {
|
||||
const data = await db.collection('objects').findOne({ _key: key });
|
||||
if (!data) {
|
||||
return;
|
||||
}
|
||||
|
||||
var randomIndex = Math.floor(Math.random() * data.members.length);
|
||||
var value = data.members[randomIndex];
|
||||
module.setRemove(data._key, value, function (err) {
|
||||
callback(err, value);
|
||||
});
|
||||
});
|
||||
var randomIndex = Math.floor(Math.random() * data.members.length);
|
||||
var value = data.members[randomIndex];
|
||||
await module.setRemove(data._key, value);
|
||||
return value;
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,44 +1,43 @@
|
||||
'use strict';
|
||||
|
||||
var async = require('async');
|
||||
var utils = require('../../utils');
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.mongo;
|
||||
var helpers = require('./helpers');
|
||||
const util = require('util');
|
||||
const sleep = util.promisify(setTimeout);
|
||||
|
||||
require('./sorted/add')(db, module);
|
||||
require('./sorted/remove')(db, module);
|
||||
require('./sorted/union')(db, module);
|
||||
require('./sorted/intersect')(db, module);
|
||||
|
||||
module.getSortedSetRange = function (key, start, stop, callback) {
|
||||
getSortedSetRange(key, start, stop, '-inf', '+inf', 1, false, callback);
|
||||
module.getSortedSetRange = async function (key, start, stop) {
|
||||
return await getSortedSetRange(key, start, stop, '-inf', '+inf', 1, false);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRange = function (key, start, stop, callback) {
|
||||
getSortedSetRange(key, start, stop, '-inf', '+inf', -1, false, callback);
|
||||
module.getSortedSetRevRange = async function (key, start, stop) {
|
||||
return await getSortedSetRange(key, start, stop, '-inf', '+inf', -1, false);
|
||||
};
|
||||
|
||||
module.getSortedSetRangeWithScores = function (key, start, stop, callback) {
|
||||
getSortedSetRange(key, start, stop, '-inf', '+inf', 1, true, callback);
|
||||
module.getSortedSetRangeWithScores = async function (key, start, stop) {
|
||||
return await getSortedSetRange(key, start, stop, '-inf', '+inf', 1, true);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRangeWithScores = function (key, start, stop, callback) {
|
||||
getSortedSetRange(key, start, stop, '-inf', '+inf', -1, true, callback);
|
||||
module.getSortedSetRevRangeWithScores = async function (key, start, stop) {
|
||||
return await getSortedSetRange(key, start, stop, '-inf', '+inf', -1, true);
|
||||
};
|
||||
|
||||
function getSortedSetRange(key, start, stop, min, max, sort, withScores, callback) {
|
||||
async function getSortedSetRange(key, start, stop, min, max, sort, withScores) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
if (start < 0 && start > stop) {
|
||||
return callback(null, []);
|
||||
const isArray = Array.isArray(key);
|
||||
if ((start < 0 && start > stop) || (isArray && !key.length)) {
|
||||
return [];
|
||||
}
|
||||
|
||||
if (Array.isArray(key)) {
|
||||
if (!key.length) {
|
||||
return setImmediate(callback, null, []);
|
||||
}
|
||||
if (isArray) {
|
||||
if (key.length > 1) {
|
||||
key = { $in: key };
|
||||
} else {
|
||||
@@ -82,53 +81,49 @@ module.exports = function (db, module) {
|
||||
limit = 0;
|
||||
}
|
||||
|
||||
db.collection('objects').find(query, { projection: fields })
|
||||
let data = await db.collection('objects').find(query, { projection: fields })
|
||||
.sort({ score: sort })
|
||||
.skip(start)
|
||||
.limit(limit)
|
||||
.toArray(function (err, data) {
|
||||
if (err || !data) {
|
||||
return callback(err);
|
||||
}
|
||||
.toArray();
|
||||
|
||||
if (reverse) {
|
||||
data.reverse();
|
||||
}
|
||||
if (!withScores) {
|
||||
data = data.map(item => item.value);
|
||||
}
|
||||
if (reverse) {
|
||||
data.reverse();
|
||||
}
|
||||
if (!withScores) {
|
||||
data = data.map(item => item.value);
|
||||
}
|
||||
|
||||
callback(null, data);
|
||||
});
|
||||
return data;
|
||||
}
|
||||
|
||||
module.getSortedSetRangeByScore = function (key, start, count, min, max, callback) {
|
||||
getSortedSetRangeByScore(key, start, count, min, max, 1, false, callback);
|
||||
module.getSortedSetRangeByScore = async function (key, start, count, min, max) {
|
||||
return await getSortedSetRangeByScore(key, start, count, min, max, 1, false);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRangeByScore = function (key, start, count, max, min, callback) {
|
||||
getSortedSetRangeByScore(key, start, count, min, max, -1, false, callback);
|
||||
module.getSortedSetRevRangeByScore = async function (key, start, count, max, min) {
|
||||
return await getSortedSetRangeByScore(key, start, count, min, max, -1, false);
|
||||
};
|
||||
|
||||
module.getSortedSetRangeByScoreWithScores = function (key, start, count, min, max, callback) {
|
||||
getSortedSetRangeByScore(key, start, count, min, max, 1, true, callback);
|
||||
module.getSortedSetRangeByScoreWithScores = async function (key, start, count, min, max) {
|
||||
return await getSortedSetRangeByScore(key, start, count, min, max, 1, true);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRangeByScoreWithScores = function (key, start, count, max, min, callback) {
|
||||
getSortedSetRangeByScore(key, start, count, min, max, -1, true, callback);
|
||||
module.getSortedSetRevRangeByScoreWithScores = async function (key, start, count, max, min) {
|
||||
return await getSortedSetRangeByScore(key, start, count, min, max, -1, true);
|
||||
};
|
||||
|
||||
function getSortedSetRangeByScore(key, start, count, min, max, sort, withScores, callback) {
|
||||
async function getSortedSetRangeByScore(key, start, count, min, max, sort, withScores) {
|
||||
if (parseInt(count, 10) === 0) {
|
||||
return setImmediate(callback, null, []);
|
||||
return [];
|
||||
}
|
||||
const stop = (parseInt(count, 10) === -1) ? -1 : (start + count - 1);
|
||||
getSortedSetRange(key, start, stop, min, max, sort, withScores, callback);
|
||||
return await getSortedSetRange(key, start, stop, min, max, sort, withScores);
|
||||
}
|
||||
|
||||
module.sortedSetCount = function (key, min, max, callback) {
|
||||
module.sortedSetCount = async function (key, min, max) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
var query = { _key: key };
|
||||
@@ -140,334 +135,268 @@ module.exports = function (db, module) {
|
||||
query.score.$lte = max;
|
||||
}
|
||||
|
||||
db.collection('objects').countDocuments(query, function (err, count) {
|
||||
callback(err, count || 0);
|
||||
});
|
||||
const count = await db.collection('objects').countDocuments(query);
|
||||
return count || 0;
|
||||
};
|
||||
|
||||
module.sortedSetCard = function (key, callback) {
|
||||
module.sortedSetCard = async function (key) {
|
||||
if (!key) {
|
||||
return callback(null, 0);
|
||||
return 0;
|
||||
}
|
||||
db.collection('objects').countDocuments({ _key: key }, function (err, count) {
|
||||
count = parseInt(count, 10);
|
||||
callback(err, count || 0);
|
||||
});
|
||||
const count = await db.collection('objects').countDocuments({ _key: key });
|
||||
return parseInt(count, 10) || 0;
|
||||
};
|
||||
|
||||
module.sortedSetsCard = function (keys, callback) {
|
||||
module.sortedSetsCard = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
async.map(keys, module.sortedSetCard, callback);
|
||||
const promises = keys.map(k => module.sortedSetCard(k));
|
||||
return await Promise.all(promises);
|
||||
};
|
||||
|
||||
module.sortedSetsCardSum = function (keys, callback) {
|
||||
module.sortedSetsCardSum = async function (keys) {
|
||||
if (!keys || (Array.isArray(keys) && !keys.length)) {
|
||||
return callback(null, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
db.collection('objects').countDocuments({ _key: Array.isArray(keys) ? { $in: keys } : keys }, function (err, count) {
|
||||
count = parseInt(count, 10);
|
||||
callback(err, count || 0);
|
||||
});
|
||||
const count = await db.collection('objects').countDocuments({ _key: Array.isArray(keys) ? { $in: keys } : keys });
|
||||
return parseInt(count, 10) || 0;
|
||||
};
|
||||
|
||||
module.sortedSetRank = function (key, value, callback) {
|
||||
getSortedSetRank(false, key, value, callback);
|
||||
module.sortedSetRank = async function (key, value) {
|
||||
return await getSortedSetRank(false, key, value);
|
||||
};
|
||||
|
||||
module.sortedSetRevRank = function (key, value, callback) {
|
||||
getSortedSetRank(true, key, value, callback);
|
||||
module.sortedSetRevRank = async function (key, value) {
|
||||
return await getSortedSetRank(true, key, value);
|
||||
};
|
||||
|
||||
function getSortedSetRank(reverse, key, value, callback) {
|
||||
async function getSortedSetRank(reverse, key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
module.sortedSetScore(key, value, function (err, score) {
|
||||
if (err || score === null) {
|
||||
return callback(err, null);
|
||||
}
|
||||
const score = await module.sortedSetScore(key, value);
|
||||
if (score === null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
db.collection('objects').countDocuments({
|
||||
$or: [
|
||||
{
|
||||
_key: key,
|
||||
score: reverse ? { $gt: score } : { $lt: score },
|
||||
},
|
||||
{
|
||||
_key: key,
|
||||
score: score,
|
||||
value: reverse ? { $gt: value } : { $lt: value },
|
||||
},
|
||||
],
|
||||
}, function (err, rank) { callback(err, rank); });
|
||||
return await db.collection('objects').countDocuments({
|
||||
$or: [
|
||||
{
|
||||
_key: key,
|
||||
score: reverse ? { $gt: score } : { $lt: score },
|
||||
},
|
||||
{
|
||||
_key: key,
|
||||
score: score,
|
||||
value: reverse ? { $gt: value } : { $lt: value },
|
||||
},
|
||||
],
|
||||
});
|
||||
}
|
||||
|
||||
module.sortedSetsRanks = function (keys, values, callback) {
|
||||
sortedSetsRanks(module.sortedSetRank, keys, values, callback);
|
||||
module.sortedSetsRanks = async function (keys, values) {
|
||||
return await sortedSetsRanks(module.sortedSetRank, keys, values);
|
||||
};
|
||||
|
||||
module.sortedSetsRevRanks = function (keys, values, callback) {
|
||||
sortedSetsRanks(module.sortedSetRevRank, keys, values, callback);
|
||||
module.sortedSetsRevRanks = async function (keys, values) {
|
||||
return await sortedSetsRanks(module.sortedSetRevRank, keys, values);
|
||||
};
|
||||
|
||||
function sortedSetsRanks(method, keys, values, callback) {
|
||||
async function sortedSetsRanks(method, keys, values) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
var data = new Array(values.length);
|
||||
for (var i = 0; i < values.length; i += 1) {
|
||||
data[i] = { key: keys[i], value: values[i] };
|
||||
}
|
||||
|
||||
async.map(data, function (item, next) {
|
||||
method(item.key, item.value, next);
|
||||
}, callback);
|
||||
const promises = data.map(item => method(item.key, item.value));
|
||||
return await Promise.all(promises);
|
||||
}
|
||||
|
||||
module.sortedSetRanks = function (key, values, callback) {
|
||||
sortedSetRanks(module.getSortedSetRange, key, values, callback);
|
||||
module.sortedSetRanks = async function (key, values) {
|
||||
return await sortedSetRanks(module.getSortedSetRange, key, values);
|
||||
};
|
||||
|
||||
module.sortedSetRevRanks = function (key, values, callback) {
|
||||
sortedSetRanks(module.getSortedSetRevRange, key, values, callback);
|
||||
module.sortedSetRevRanks = async function (key, values) {
|
||||
return await sortedSetRanks(module.getSortedSetRevRange, key, values);
|
||||
};
|
||||
|
||||
function sortedSetRanks(method, key, values, callback) {
|
||||
method(key, 0, -1, function (err, sortedSet) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
async function sortedSetRanks(method, key, values) {
|
||||
const sortedSet = await method(key, 0, -1);
|
||||
|
||||
var result = values.map(function (value) {
|
||||
if (!value) {
|
||||
return null;
|
||||
}
|
||||
|
||||
var result = values.map(function (value) {
|
||||
if (!value) {
|
||||
return null;
|
||||
}
|
||||
var index = sortedSet.indexOf(value.toString());
|
||||
return index !== -1 ? index : null;
|
||||
});
|
||||
|
||||
callback(null, result);
|
||||
var index = sortedSet.indexOf(value.toString());
|
||||
return index !== -1 ? index : null;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
module.sortedSetScore = function (key, value, callback) {
|
||||
module.sortedSetScore = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback(null, null);
|
||||
return null;
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
db.collection('objects').findOne({ _key: key, value: value }, { projection: { _id: 0, _key: 0, value: 0 } }, function (err, result) {
|
||||
callback(err, result ? result.score : null);
|
||||
});
|
||||
const result = await db.collection('objects').findOne({ _key: key, value: value }, { projection: { _id: 0, _key: 0, value: 0 } });
|
||||
return result ? result.score : null;
|
||||
};
|
||||
|
||||
module.sortedSetsScore = function (keys, value, callback) {
|
||||
module.sortedSetsScore = async function (keys, value) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
db.collection('objects').find({ _key: { $in: keys }, value: value }, { projection: { _id: 0, value: 0 } }).toArray(function (err, result) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
const result = await db.collection('objects').find({ _key: { $in: keys }, value: value }, { projection: { _id: 0, value: 0 } }).toArray();
|
||||
var map = {};
|
||||
result.forEach(function (item) {
|
||||
if (item) {
|
||||
map[item._key] = item;
|
||||
}
|
||||
|
||||
var map = {};
|
||||
result.forEach(function (item) {
|
||||
if (item) {
|
||||
map[item._key] = item;
|
||||
}
|
||||
});
|
||||
|
||||
result = keys.map(function (key) {
|
||||
return map[key] ? map[key].score : null;
|
||||
});
|
||||
|
||||
callback(null, result);
|
||||
});
|
||||
|
||||
return keys.map(key => (map[key] ? map[key].score : null));
|
||||
};
|
||||
|
||||
module.sortedSetScores = function (key, values, callback) {
|
||||
module.sortedSetScores = async function (key, values) {
|
||||
if (!key) {
|
||||
return setImmediate(callback, null, null);
|
||||
return null;
|
||||
}
|
||||
if (!values.length) {
|
||||
return setImmediate(callback, null, []);
|
||||
return [];
|
||||
}
|
||||
values = values.map(helpers.valueToString);
|
||||
db.collection('objects').find({ _key: key, value: { $in: values } }, { projection: { _id: 0, _key: 0 } }).toArray(function (err, result) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
const result = await db.collection('objects').find({ _key: key, value: { $in: values } }, { projection: { _id: 0, _key: 0 } }).toArray();
|
||||
|
||||
var valueToScore = {};
|
||||
result.forEach(function (item) {
|
||||
if (item) {
|
||||
valueToScore[item.value] = item.score;
|
||||
}
|
||||
|
||||
var map = {};
|
||||
result.forEach(function (item) {
|
||||
map[item.value] = item.score;
|
||||
});
|
||||
|
||||
var returnData = new Array(values.length);
|
||||
var score;
|
||||
|
||||
for (var i = 0; i < values.length; i += 1) {
|
||||
score = map[values[i]];
|
||||
returnData[i] = utils.isNumber(score) ? score : null;
|
||||
}
|
||||
|
||||
callback(null, returnData);
|
||||
});
|
||||
|
||||
return values.map(v => (utils.isNumber(valueToScore[v]) ? valueToScore[v] : null));
|
||||
};
|
||||
|
||||
module.isSortedSetMember = function (key, value, callback) {
|
||||
module.isSortedSetMember = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
db.collection('objects').findOne({ _key: key, value: value }, { projection: { _id: 0, _key: 0, score: 0 } }, function (err, result) {
|
||||
callback(err, !!result);
|
||||
});
|
||||
const result = await db.collection('objects').findOne({ _key: key, value: value }, { projection: { _id: 0, _key: 0, score: 0 } });
|
||||
return !!result;
|
||||
};
|
||||
|
||||
module.isSortedSetMembers = function (key, values, callback) {
|
||||
module.isSortedSetMembers = async function (key, values) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
values = values.map(helpers.valueToString);
|
||||
db.collection('objects').find({ _key: key, value: { $in: values } }, { projection: { _id: 0, _key: 0, score: 0 } }).toArray(function (err, results) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
var isMember = {};
|
||||
results.forEach(function (item) {
|
||||
if (item) {
|
||||
isMember[item.value] = true;
|
||||
}
|
||||
});
|
||||
const results = await db.collection('objects').find({ _key: key, value: { $in: values } }, { projection: { _id: 0, _key: 0, score: 0 } }).toArray();
|
||||
|
||||
values = values.map(function (value) {
|
||||
return !!isMember[value];
|
||||
});
|
||||
callback(null, values);
|
||||
var isMember = {};
|
||||
results.forEach(function (item) {
|
||||
if (item) {
|
||||
isMember[item.value] = true;
|
||||
}
|
||||
});
|
||||
|
||||
return values.map(value => !!isMember[value]);
|
||||
};
|
||||
|
||||
module.isMemberOfSortedSets = function (keys, value, callback) {
|
||||
module.isMemberOfSortedSets = async function (keys, value) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return setImmediate(callback, null, []);
|
||||
return [];
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
db.collection('objects').find({ _key: { $in: keys }, value: value }, { projection: { _id: 0, score: 0 } }).toArray(function (err, results) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
var isMember = {};
|
||||
results.forEach(function (item) {
|
||||
if (item) {
|
||||
isMember[item._key] = true;
|
||||
}
|
||||
});
|
||||
const results = await db.collection('objects').find({ _key: { $in: keys }, value: value }, { projection: { _id: 0, score: 0 } }).toArray();
|
||||
|
||||
results = keys.map(function (key) {
|
||||
return !!isMember[key];
|
||||
});
|
||||
callback(null, results);
|
||||
var isMember = {};
|
||||
results.forEach(function (item) {
|
||||
if (item) {
|
||||
isMember[item._key] = true;
|
||||
}
|
||||
});
|
||||
|
||||
return keys.map(key => !!isMember[key]);
|
||||
};
|
||||
|
||||
module.getSortedSetsMembers = function (keys, callback) {
|
||||
module.getSortedSetsMembers = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return setImmediate(callback, null, []);
|
||||
return [];
|
||||
}
|
||||
db.collection('objects').find({ _key: { $in: keys } }, { projection: { _id: 0, score: 0 } }).sort({ score: 1 }).toArray(function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
const data = await db.collection('objects').find({ _key: { $in: keys } }, { projection: { _id: 0, score: 0 } }).sort({ score: 1 }).toArray();
|
||||
|
||||
var sets = {};
|
||||
data.forEach(function (set) {
|
||||
sets[set._key] = sets[set._key] || [];
|
||||
sets[set._key].push(set.value);
|
||||
});
|
||||
|
||||
var returnData = new Array(keys.length);
|
||||
for (var i = 0; i < keys.length; i += 1) {
|
||||
returnData[i] = sets[keys[i]] || [];
|
||||
}
|
||||
callback(null, returnData);
|
||||
var sets = {};
|
||||
data.forEach(function (set) {
|
||||
sets[set._key] = sets[set._key] || [];
|
||||
sets[set._key].push(set.value);
|
||||
});
|
||||
|
||||
return keys.map(k => sets[k] || []);
|
||||
};
|
||||
|
||||
module.sortedSetIncrBy = function (key, increment, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.sortedSetIncrBy = async function (key, increment, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
var data = {};
|
||||
value = helpers.valueToString(value);
|
||||
data.score = parseFloat(increment);
|
||||
|
||||
db.collection('objects').findOneAndUpdate({ _key: key, value: value }, { $inc: data }, { returnOriginal: false, upsert: true }, function (err, result) {
|
||||
try {
|
||||
const result = await db.collection('objects').findOneAndUpdate({ _key: key, value: value }, { $inc: data }, { returnOriginal: false, upsert: true });
|
||||
return result && result.value ? result.value.score : null;
|
||||
} catch (err) {
|
||||
// if there is duplicate key error retry the upsert
|
||||
// https://github.com/NodeBB/NodeBB/issues/4467
|
||||
// https://jira.mongodb.org/browse/SERVER-14322
|
||||
// https://docs.mongodb.org/manual/reference/command/findAndModify/#upsert-and-unique-index
|
||||
if (err && err.message.startsWith('E11000 duplicate key error')) {
|
||||
return process.nextTick(module.sortedSetIncrBy, key, increment, value, callback);
|
||||
return await module.sortedSetIncrBy(key, increment, value);
|
||||
}
|
||||
callback(err, result && result.value ? result.value.score : null);
|
||||
});
|
||||
};
|
||||
|
||||
module.getSortedSetRangeByLex = function (key, min, max, start, count, callback) {
|
||||
sortedSetLex(key, min, max, 1, start, count, callback);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRangeByLex = function (key, max, min, start, count, callback) {
|
||||
sortedSetLex(key, min, max, -1, start, count, callback);
|
||||
};
|
||||
|
||||
module.sortedSetLexCount = function (key, min, max, callback) {
|
||||
sortedSetLex(key, min, max, 1, 0, 0, function (err, data) {
|
||||
callback(err, data ? data.length : null);
|
||||
});
|
||||
};
|
||||
|
||||
function sortedSetLex(key, min, max, sort, start, count, callback) {
|
||||
if (!callback) {
|
||||
callback = start;
|
||||
start = 0;
|
||||
count = 0;
|
||||
throw err;
|
||||
}
|
||||
};
|
||||
|
||||
module.getSortedSetRangeByLex = async function (key, min, max, start, count) {
|
||||
return await sortedSetLex(key, min, max, 1, start, count);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRangeByLex = async function (key, max, min, start, count) {
|
||||
return await sortedSetLex(key, min, max, -1, start, count);
|
||||
};
|
||||
|
||||
module.sortedSetLexCount = async function (key, min, max) {
|
||||
const data = await sortedSetLex(key, min, max, 1, 0, 0);
|
||||
return data ? data.length : null;
|
||||
};
|
||||
|
||||
async function sortedSetLex(key, min, max, sort, start, count) {
|
||||
var query = { _key: key };
|
||||
start = start !== undefined ? start : 0;
|
||||
count = count !== undefined ? count : 0;
|
||||
buildLexQuery(query, min, max);
|
||||
|
||||
db.collection('objects').find(query, { projection: { _id: 0, _key: 0, score: 0 } })
|
||||
const data = await db.collection('objects').find(query, { projection: { _id: 0, _key: 0, score: 0 } })
|
||||
.sort({ value: sort })
|
||||
.skip(start)
|
||||
.limit(count === -1 ? 0 : count)
|
||||
.toArray(function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
data = data.map(function (item) {
|
||||
return item && item.value;
|
||||
});
|
||||
callback(err, data);
|
||||
});
|
||||
.toArray();
|
||||
|
||||
return data.map(item => item && item.value);
|
||||
}
|
||||
|
||||
module.sortedSetRemoveRangeByLex = function (key, min, max, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.sortedSetRemoveRangeByLex = async function (key, min, max) {
|
||||
var query = { _key: key };
|
||||
buildLexQuery(query, min, max);
|
||||
|
||||
db.collection('objects').deleteMany(query, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await db.collection('objects').deleteMany(query);
|
||||
};
|
||||
|
||||
function buildLexQuery(query, min, max) {
|
||||
@@ -492,51 +421,39 @@ module.exports = function (db, module) {
|
||||
}
|
||||
}
|
||||
|
||||
module.processSortedSet = function (setKey, processFn, options, callback) {
|
||||
module.processSortedSet = async function (setKey, processFn, options) {
|
||||
var done = false;
|
||||
var ids = [];
|
||||
var project = { _id: 0, _key: 0 };
|
||||
|
||||
if (!options.withScores) {
|
||||
project.score = 0;
|
||||
}
|
||||
var cursor = db.collection('objects').find({ _key: setKey }, { projection: project })
|
||||
var cursor = await db.collection('objects').find({ _key: setKey }, { projection: project })
|
||||
.sort({ score: 1 })
|
||||
.batchSize(options.batch);
|
||||
|
||||
async.whilst(
|
||||
function (next) {
|
||||
next(null, !done);
|
||||
},
|
||||
function (next) {
|
||||
async.waterfall([
|
||||
function (next) {
|
||||
cursor.next(next);
|
||||
},
|
||||
function (item, _next) {
|
||||
if (item === null) {
|
||||
done = true;
|
||||
} else {
|
||||
ids.push(options.withScores ? item : item.value);
|
||||
}
|
||||
if (processFn && processFn.constructor && processFn.constructor.name !== 'AsyncFunction') {
|
||||
processFn = util.promisify(processFn);
|
||||
}
|
||||
|
||||
if (ids.length < options.batch && (!done || ids.length === 0)) {
|
||||
return process.nextTick(next, null);
|
||||
}
|
||||
processFn(ids, function (err) {
|
||||
_next(err);
|
||||
});
|
||||
},
|
||||
function (next) {
|
||||
ids = [];
|
||||
if (options.interval) {
|
||||
setTimeout(next, options.interval);
|
||||
} else {
|
||||
process.nextTick(next);
|
||||
}
|
||||
},
|
||||
], next);
|
||||
},
|
||||
callback
|
||||
);
|
||||
while (!done) {
|
||||
/* eslint-disable no-await-in-loop */
|
||||
const item = await cursor.next();
|
||||
if (item === null) {
|
||||
done = true;
|
||||
} else {
|
||||
ids.push(options.withScores ? item : item.value);
|
||||
}
|
||||
|
||||
if (ids.length >= options.batch || (done && ids.length !== 0)) {
|
||||
await processFn(ids);
|
||||
|
||||
ids.length = 0;
|
||||
if (options.interval) {
|
||||
await sleep(options.interval);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,88 +1,82 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.mongo;
|
||||
var helpers = require('../helpers');
|
||||
var utils = require('../../../utils');
|
||||
|
||||
module.sortedSetAdd = function (key, score, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.sortedSetAdd = async function (key, score, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
if (Array.isArray(score) && Array.isArray(value)) {
|
||||
return sortedSetAddBulk(key, score, value, callback);
|
||||
return await sortedSetAddBulk(key, score, value);
|
||||
}
|
||||
if (!utils.isNumber(score)) {
|
||||
return setImmediate(callback, new Error('[[error:invalid-score, ' + score + ']]'));
|
||||
throw new Error('[[error:invalid-score, ' + score + ']]');
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
db.collection('objects').updateOne({ _key: key, value: value }, { $set: { score: parseFloat(score) } }, { upsert: true, w: 1 }, function (err) {
|
||||
try {
|
||||
await db.collection('objects').updateOne({ _key: key, value: value }, { $set: { score: parseFloat(score) } }, { upsert: true, w: 1 });
|
||||
} catch (err) {
|
||||
if (err && err.message.startsWith('E11000 duplicate key error')) {
|
||||
return process.nextTick(module.sortedSetAdd, key, score, value, callback);
|
||||
return await module.sortedSetAdd(key, score, value);
|
||||
}
|
||||
callback(err);
|
||||
});
|
||||
throw err;
|
||||
}
|
||||
};
|
||||
|
||||
function sortedSetAddBulk(key, scores, values, callback) {
|
||||
async function sortedSetAddBulk(key, scores, values) {
|
||||
if (!scores.length || !values.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
if (scores.length !== values.length) {
|
||||
return callback(new Error('[[error:invalid-data]]'));
|
||||
throw new Error('[[error:invalid-data]]');
|
||||
}
|
||||
for (let i = 0; i < scores.length; i += 1) {
|
||||
if (!utils.isNumber(scores[i])) {
|
||||
return setImmediate(callback, new Error('[[error:invalid-score, ' + scores[i] + ']]'));
|
||||
throw new Error('[[error:invalid-score, ' + scores[i] + ']]');
|
||||
}
|
||||
}
|
||||
values = values.map(helpers.valueToString);
|
||||
|
||||
var bulk = db.collection('objects').initializeUnorderedBulkOp();
|
||||
|
||||
for (var i = 0; i < scores.length; i += 1) {
|
||||
bulk.find({ _key: key, value: values[i] }).upsert().updateOne({ $set: { score: parseFloat(scores[i]) } });
|
||||
}
|
||||
|
||||
bulk.execute(function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await bulk.execute();
|
||||
}
|
||||
|
||||
module.sortedSetsAdd = function (keys, scores, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.sortedSetsAdd = async function (keys, scores, value) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return setImmediate(callback);
|
||||
return;
|
||||
}
|
||||
const isArrayOfScores = Array.isArray(scores);
|
||||
if (!isArrayOfScores && !utils.isNumber(scores)) {
|
||||
return setImmediate(callback, new Error('[[error:invalid-score, ' + scores + ']]'));
|
||||
throw new Error('[[error:invalid-score, ' + scores + ']]');
|
||||
}
|
||||
|
||||
if (isArrayOfScores && scores.length !== keys.length) {
|
||||
return setImmediate(callback, new Error('[[error:invalid-data]]'));
|
||||
throw new Error('[[error:invalid-data]]');
|
||||
}
|
||||
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
var bulk = db.collection('objects').initializeUnorderedBulkOp();
|
||||
|
||||
for (var i = 0; i < keys.length; i += 1) {
|
||||
bulk.find({ _key: keys[i], value: value }).upsert().updateOne({ $set: { score: parseFloat(isArrayOfScores ? scores[i] : scores) } });
|
||||
}
|
||||
|
||||
bulk.execute(err => callback(err));
|
||||
await bulk.execute();
|
||||
};
|
||||
|
||||
module.sortedSetAddBulk = function (data, callback) {
|
||||
module.sortedSetAddBulk = async function (data) {
|
||||
if (!Array.isArray(data) || !data.length) {
|
||||
return setImmediate(callback);
|
||||
return;
|
||||
}
|
||||
var bulk = db.collection('objects').initializeUnorderedBulkOp();
|
||||
data.forEach(function (item) {
|
||||
bulk.find({ _key: item[0], value: String(item[2]) }).upsert().updateOne({ $set: { score: parseFloat(item[1]) } });
|
||||
});
|
||||
bulk.execute(err => callback(err));
|
||||
await bulk.execute();
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (db, module) {
|
||||
module.sortedSetIntersectCard = function (keys, callback) {
|
||||
module.sortedSetIntersectCard = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
var pipeline = [
|
||||
@@ -13,23 +13,22 @@ module.exports = function (db, module) {
|
||||
{ $group: { _id: null, count: { $sum: 1 } } },
|
||||
];
|
||||
|
||||
db.collection('objects').aggregate(pipeline).toArray(function (err, data) {
|
||||
callback(err, Array.isArray(data) && data.length ? data[0].count : 0);
|
||||
});
|
||||
const data = await db.collection('objects').aggregate(pipeline).toArray();
|
||||
return Array.isArray(data) && data.length ? data[0].count : 0;
|
||||
};
|
||||
|
||||
|
||||
module.getSortedSetIntersect = function (params, callback) {
|
||||
module.getSortedSetIntersect = async function (params) {
|
||||
params.sort = 1;
|
||||
getSortedSetRevIntersect(params, callback);
|
||||
return await getSortedSetRevIntersect(params);
|
||||
};
|
||||
|
||||
module.getSortedSetRevIntersect = function (params, callback) {
|
||||
module.getSortedSetRevIntersect = async function (params) {
|
||||
params.sort = -1;
|
||||
getSortedSetRevIntersect(params, callback);
|
||||
return await getSortedSetRevIntersect(params);
|
||||
};
|
||||
|
||||
function getSortedSetRevIntersect(params, callback) {
|
||||
async function getSortedSetRevIntersect(params) {
|
||||
var sets = params.sets;
|
||||
var start = params.hasOwnProperty('start') ? params.start : 0;
|
||||
var stop = params.hasOwnProperty('stop') ? params.stop : -1;
|
||||
@@ -88,18 +87,11 @@ module.exports = function (db, module) {
|
||||
}
|
||||
pipeline.push({ $project: project });
|
||||
|
||||
db.collection('objects').aggregate(pipeline).toArray(function (err, data) {
|
||||
if (err || !data) {
|
||||
return callback(err);
|
||||
}
|
||||
let data = await db.collection('objects').aggregate(pipeline).toArray();
|
||||
|
||||
if (!params.withScores) {
|
||||
data = data.map(function (item) {
|
||||
return item.value;
|
||||
});
|
||||
}
|
||||
|
||||
callback(null, data);
|
||||
});
|
||||
if (!params.withScores) {
|
||||
data = data.map(item => item.value);
|
||||
}
|
||||
return data;
|
||||
}
|
||||
};
|
||||
|
||||
@@ -1,45 +1,41 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.mongo;
|
||||
var helpers = require('../helpers');
|
||||
|
||||
module.sortedSetRemove = function (key, value, callback) {
|
||||
function done(err) {
|
||||
callback(err);
|
||||
}
|
||||
callback = callback || helpers.noop;
|
||||
module.sortedSetRemove = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
const isValueArray = Array.isArray(value);
|
||||
if (!value || (isValueArray && !value.length)) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (Array.isArray(value)) {
|
||||
if (isValueArray) {
|
||||
value = value.map(helpers.valueToString);
|
||||
} else {
|
||||
value = helpers.valueToString(value);
|
||||
}
|
||||
|
||||
db.collection('objects').deleteMany({
|
||||
await db.collection('objects').deleteMany({
|
||||
_key: Array.isArray(key) ? { $in: key } : key,
|
||||
value: Array.isArray(value) ? { $in: value } : value,
|
||||
}, done);
|
||||
};
|
||||
|
||||
module.sortedSetsRemove = function (keys, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback();
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
db.collection('objects').deleteMany({ _key: { $in: keys }, value: value }, function (err) {
|
||||
callback(err);
|
||||
value: isValueArray ? { $in: value } : value,
|
||||
});
|
||||
};
|
||||
|
||||
module.sortedSetsRemoveRangeByScore = function (keys, min, max, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.sortedSetsRemove = async function (keys, value) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
await db.collection('objects').deleteMany({ _key: { $in: keys }, value: value });
|
||||
};
|
||||
|
||||
module.sortedSetsRemoveRangeByScore = async function (keys, min, max) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return;
|
||||
}
|
||||
var query = { _key: { $in: keys } };
|
||||
|
||||
@@ -51,8 +47,6 @@ module.exports = function (db, module) {
|
||||
query.score.$lte = parseFloat(max);
|
||||
}
|
||||
|
||||
db.collection('objects').deleteMany(query, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await db.collection('objects').deleteMany(query);
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,34 +1,33 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (db, module) {
|
||||
module.sortedSetUnionCard = function (keys, callback) {
|
||||
module.sortedSetUnionCard = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
db.collection('objects').aggregate([
|
||||
const data = await db.collection('objects').aggregate([
|
||||
{ $match: { _key: { $in: keys } } },
|
||||
{ $group: { _id: { value: '$value' } } },
|
||||
{ $group: { _id: null, count: { $sum: 1 } } },
|
||||
{ $project: { _id: 0, count: '$count' } },
|
||||
]).toArray(function (err, data) {
|
||||
callback(err, Array.isArray(data) && data.length ? data[0].count : 0);
|
||||
});
|
||||
]).toArray();
|
||||
return Array.isArray(data) && data.length ? data[0].count : 0;
|
||||
};
|
||||
|
||||
module.getSortedSetUnion = function (params, callback) {
|
||||
module.getSortedSetUnion = async function (params) {
|
||||
params.sort = 1;
|
||||
getSortedSetUnion(params, callback);
|
||||
return await getSortedSetUnion(params);
|
||||
};
|
||||
|
||||
module.getSortedSetRevUnion = function (params, callback) {
|
||||
module.getSortedSetRevUnion = async function (params) {
|
||||
params.sort = -1;
|
||||
getSortedSetUnion(params, callback);
|
||||
return await getSortedSetUnion(params);
|
||||
};
|
||||
|
||||
function getSortedSetUnion(params, callback) {
|
||||
async function getSortedSetUnion(params) {
|
||||
if (!Array.isArray(params.sets) || !params.sets.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
var limit = params.stop - params.start + 1;
|
||||
if (limit <= 0) {
|
||||
@@ -62,18 +61,10 @@ module.exports = function (db, module) {
|
||||
}
|
||||
pipeline.push({ $project: project });
|
||||
|
||||
db.collection('objects').aggregate(pipeline).toArray(function (err, data) {
|
||||
if (err || !data) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (!params.withScores) {
|
||||
data = data.map(function (item) {
|
||||
return item.value;
|
||||
});
|
||||
}
|
||||
|
||||
callback(null, data);
|
||||
});
|
||||
let data = await db.collection('objects').aggregate(pipeline).toArray();
|
||||
if (!params.withScores) {
|
||||
data = data.map(item => item.value);
|
||||
}
|
||||
return data;
|
||||
}
|
||||
};
|
||||
|
||||
@@ -6,8 +6,6 @@ var nconf = require('nconf');
|
||||
var session = require('express-session');
|
||||
var _ = require('lodash');
|
||||
var semver = require('semver');
|
||||
var dbNamespace = require('continuation-local-storage').createNamespace('postgres');
|
||||
|
||||
|
||||
var postgresModule = module.exports;
|
||||
|
||||
@@ -41,9 +39,6 @@ postgresModule.questions = [
|
||||
},
|
||||
];
|
||||
|
||||
postgresModule.helpers = postgresModule.helpers || {};
|
||||
postgresModule.helpers.postgres = require('./postgres/helpers');
|
||||
|
||||
postgresModule.getConnectionOptions = function (postgres) {
|
||||
postgres = postgres || nconf.get('postgres');
|
||||
// Sensible defaults for PostgreSQL, if not set
|
||||
@@ -79,17 +74,6 @@ postgresModule.init = function (callback) {
|
||||
|
||||
const db = new Pool(connOptions);
|
||||
|
||||
db.on('connect', function (client) {
|
||||
var realQuery = client.query;
|
||||
client.query = function () {
|
||||
var args = Array.prototype.slice.call(arguments, 0);
|
||||
if (dbNamespace.active && typeof args[args.length - 1] === 'function') {
|
||||
args[args.length - 1] = dbNamespace.bind(args[args.length - 1]);
|
||||
}
|
||||
return realQuery.apply(client, args);
|
||||
};
|
||||
});
|
||||
|
||||
db.connect(function (err, client, release) {
|
||||
if (err) {
|
||||
winston.error('NodeBB could not connect to your PostgreSQL database. PostgreSQL returned the following error: ' + err.message);
|
||||
@@ -99,7 +83,7 @@ postgresModule.init = function (callback) {
|
||||
postgresModule.pool = db;
|
||||
Object.defineProperty(postgresModule, 'client', {
|
||||
get: function () {
|
||||
return (dbNamespace.active && dbNamespace.get('db')) || db;
|
||||
return db;
|
||||
},
|
||||
configurable: true,
|
||||
});
|
||||
@@ -124,10 +108,9 @@ postgresModule.init = function (callback) {
|
||||
require('./postgres/sets')(wrappedDB, postgresModule);
|
||||
require('./postgres/sorted')(wrappedDB, postgresModule);
|
||||
require('./postgres/list')(wrappedDB, postgresModule);
|
||||
require('./postgres/transaction')(db, dbNamespace, postgresModule);
|
||||
|
||||
postgresModule.async = require('../promisify')(postgresModule, ['client', 'sessionStore', 'pool']);
|
||||
require('./postgres/transaction')(db, postgresModule);
|
||||
|
||||
postgresModule.async = require('../promisify')(postgresModule, ['client', 'sessionStore', 'pool', 'transaction']);
|
||||
callback();
|
||||
});
|
||||
});
|
||||
@@ -140,17 +123,6 @@ postgresModule.connect = function (options, callback) {
|
||||
|
||||
const db = new Pool(connOptions);
|
||||
|
||||
db.on('connect', function (client) {
|
||||
var realQuery = client.query;
|
||||
client.query = function () {
|
||||
var args = Array.prototype.slice.call(arguments, 0);
|
||||
if (dbNamespace.active && typeof args[args.length - 1] === 'function') {
|
||||
args[args.length - 1] = dbNamespace.bind(args[args.length - 1]);
|
||||
}
|
||||
return realQuery.apply(client, args);
|
||||
};
|
||||
});
|
||||
|
||||
db.connect(function (err) {
|
||||
callback(err, db);
|
||||
});
|
||||
|
||||
@@ -1,74 +1,59 @@
|
||||
'use strict';
|
||||
|
||||
var async = require('async');
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.postgres;
|
||||
|
||||
module.setObject = function (key, data, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
var helpers = require('./helpers');
|
||||
|
||||
module.setObject = async function (key, data) {
|
||||
if (!key || !data) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
if (data.hasOwnProperty('')) {
|
||||
delete data[''];
|
||||
}
|
||||
|
||||
module.transaction(function (tx, done) {
|
||||
var query = tx.client.query.bind(tx.client);
|
||||
await module.transaction(async function (client) {
|
||||
var query = client.query.bind(client);
|
||||
|
||||
async.series([
|
||||
async.apply(helpers.ensureLegacyObjectType, tx.client, key, 'hash'),
|
||||
async.apply(query, {
|
||||
name: 'setObject',
|
||||
text: `
|
||||
await helpers.ensureLegacyObjectType(client, key, 'hash');
|
||||
await query({
|
||||
name: 'setObject',
|
||||
text: `
|
||||
INSERT INTO "legacy_hash" ("_key", "data")
|
||||
VALUES ($1::TEXT, $2::TEXT::JSONB)
|
||||
ON CONFLICT ("_key")
|
||||
DO UPDATE SET "data" = "legacy_hash"."data" || $2::TEXT::JSONB`,
|
||||
values: [key, JSON.stringify(data)],
|
||||
}),
|
||||
], function (err) {
|
||||
done(err);
|
||||
ON CONFLICT ("_key")
|
||||
DO UPDATE SET "data" = "legacy_hash"."data" || $2::TEXT::JSONB`,
|
||||
values: [key, JSON.stringify(data)],
|
||||
});
|
||||
}, callback);
|
||||
});
|
||||
};
|
||||
|
||||
module.setObjectField = function (key, field, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.setObjectField = async function (key, field, value) {
|
||||
if (!field) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
module.transaction(function (tx, done) {
|
||||
var query = tx.client.query.bind(tx.client);
|
||||
|
||||
async.series([
|
||||
async.apply(helpers.ensureLegacyObjectType, tx.client, key, 'hash'),
|
||||
async.apply(query, {
|
||||
name: 'setObjectField',
|
||||
text: `
|
||||
await module.transaction(async function (client) {
|
||||
var query = client.query.bind(client);
|
||||
await helpers.ensureLegacyObjectType(client, key, 'hash');
|
||||
await query({
|
||||
name: 'setObjectField',
|
||||
text: `
|
||||
INSERT INTO "legacy_hash" ("_key", "data")
|
||||
VALUES ($1::TEXT, jsonb_build_object($2::TEXT, $3::TEXT::JSONB))
|
||||
ON CONFLICT ("_key")
|
||||
DO UPDATE SET "data" = jsonb_set("legacy_hash"."data", ARRAY[$2::TEXT], $3::TEXT::JSONB)`,
|
||||
values: [key, field, JSON.stringify(value)],
|
||||
}),
|
||||
], function (err) {
|
||||
done(err);
|
||||
ON CONFLICT ("_key")
|
||||
DO UPDATE SET "data" = jsonb_set("legacy_hash"."data", ARRAY[$2::TEXT], $3::TEXT::JSONB)`,
|
||||
values: [key, field, JSON.stringify(value)],
|
||||
});
|
||||
}, callback);
|
||||
});
|
||||
};
|
||||
|
||||
module.getObject = function (key, callback) {
|
||||
module.getObject = async function (key) {
|
||||
if (!key) {
|
||||
return callback(null, null);
|
||||
return null;
|
||||
}
|
||||
|
||||
db.query({
|
||||
const res = await db.query({
|
||||
name: 'getObject',
|
||||
text: `
|
||||
SELECT h."data"
|
||||
@@ -79,25 +64,17 @@ SELECT h."data"
|
||||
WHERE o."_key" = $1::TEXT
|
||||
LIMIT 1`,
|
||||
values: [key],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (res.rows.length) {
|
||||
return callback(null, res.rows[0].data);
|
||||
}
|
||||
|
||||
callback(null, null);
|
||||
});
|
||||
|
||||
return res.rows.length ? res.rows[0].data : null;
|
||||
};
|
||||
|
||||
module.getObjects = function (keys, callback) {
|
||||
module.getObjects = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
|
||||
db.query({
|
||||
const res = await db.query({
|
||||
name: 'getObjects',
|
||||
text: `
|
||||
SELECT h."data"
|
||||
@@ -109,23 +86,17 @@ SELECT h."data"
|
||||
AND o."type" = h."type"
|
||||
ORDER BY k.i ASC`,
|
||||
values: [keys],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
callback(null, res.rows.map(function (row) {
|
||||
return row.data;
|
||||
}));
|
||||
});
|
||||
|
||||
return res.rows.map(row => row.data);
|
||||
};
|
||||
|
||||
module.getObjectField = function (key, field, callback) {
|
||||
module.getObjectField = async function (key, field) {
|
||||
if (!key) {
|
||||
return setImmediate(callback, null, null);
|
||||
return null;
|
||||
}
|
||||
|
||||
db.query({
|
||||
const res = await db.query({
|
||||
name: 'getObjectField',
|
||||
text: `
|
||||
SELECT h."data"->>$2::TEXT f
|
||||
@@ -136,25 +107,17 @@ SELECT h."data"->>$2::TEXT f
|
||||
WHERE o."_key" = $1::TEXT
|
||||
LIMIT 1`,
|
||||
values: [key, field],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (res.rows.length) {
|
||||
return callback(null, res.rows[0].f);
|
||||
}
|
||||
|
||||
callback(null, null);
|
||||
});
|
||||
|
||||
return res.rows.length ? res.rows[0].f : null;
|
||||
};
|
||||
|
||||
module.getObjectFields = function (key, fields, callback) {
|
||||
module.getObjectFields = async function (key, fields) {
|
||||
if (!key) {
|
||||
return setImmediate(callback, null, null);
|
||||
return null;
|
||||
}
|
||||
|
||||
db.query({
|
||||
const res = await db.query({
|
||||
name: 'getObjectFields',
|
||||
text: `
|
||||
SELECT (SELECT jsonb_object_agg(f, d."value")
|
||||
@@ -167,30 +130,26 @@ SELECT (SELECT jsonb_object_agg(f, d."value")
|
||||
AND o."type" = h."type"
|
||||
WHERE o."_key" = $1::TEXT`,
|
||||
values: [key, fields],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (res.rows.length) {
|
||||
return callback(null, res.rows[0].d);
|
||||
}
|
||||
|
||||
var obj = {};
|
||||
fields.forEach(function (f) {
|
||||
obj[f] = null;
|
||||
});
|
||||
|
||||
callback(null, obj);
|
||||
});
|
||||
};
|
||||
|
||||
module.getObjectsFields = function (keys, fields, callback) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, []);
|
||||
if (res.rows.length) {
|
||||
return res.rows[0].d;
|
||||
}
|
||||
|
||||
db.query({
|
||||
var obj = {};
|
||||
fields.forEach(function (f) {
|
||||
obj[f] = null;
|
||||
});
|
||||
|
||||
return obj;
|
||||
};
|
||||
|
||||
module.getObjectsFields = async function (keys, fields) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return [];
|
||||
}
|
||||
|
||||
const res = await db.query({
|
||||
name: 'getObjectsFields',
|
||||
text: `
|
||||
SELECT (SELECT jsonb_object_agg(f, d."value")
|
||||
@@ -205,23 +164,17 @@ SELECT (SELECT jsonb_object_agg(f, d."value")
|
||||
AND o."type" = h."type"
|
||||
ORDER BY k.i ASC`,
|
||||
values: [keys, fields],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
callback(null, res.rows.map(function (row) {
|
||||
return row.d;
|
||||
}));
|
||||
});
|
||||
|
||||
return res.rows.map(row => row.d);
|
||||
};
|
||||
|
||||
module.getObjectKeys = function (key, callback) {
|
||||
module.getObjectKeys = async function (key) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
db.query({
|
||||
const res = await db.query({
|
||||
name: 'getObjectKeys',
|
||||
text: `
|
||||
SELECT ARRAY(SELECT jsonb_object_keys(h."data")) k
|
||||
@@ -232,45 +185,22 @@ SELECT ARRAY(SELECT jsonb_object_keys(h."data")) k
|
||||
WHERE o."_key" = $1::TEXT
|
||||
LIMIT 1`,
|
||||
values: [key],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (res.rows.length) {
|
||||
return callback(null, res.rows[0].k);
|
||||
}
|
||||
|
||||
callback(null, []);
|
||||
});
|
||||
|
||||
return res.rows.length ? res.rows[0].k : [];
|
||||
};
|
||||
|
||||
module.getObjectValues = function (key, callback) {
|
||||
module.getObject(key, function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
var values = [];
|
||||
|
||||
if (data) {
|
||||
for (var key in data) {
|
||||
if (data.hasOwnProperty(key)) {
|
||||
values.push(data[key]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
callback(null, values);
|
||||
});
|
||||
module.getObjectValues = async function (key) {
|
||||
const data = await module.getObject(key);
|
||||
return data ? Object.values(data) : [];
|
||||
};
|
||||
|
||||
module.isObjectField = function (key, field, callback) {
|
||||
module.isObjectField = async function (key, field) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
db.query({
|
||||
const res = await db.query({
|
||||
name: 'isObjectField',
|
||||
text: `
|
||||
SELECT (h."data" ? $2::TEXT AND h."data"->>$2::TEXT IS NOT NULL) b
|
||||
@@ -281,52 +211,33 @@ SELECT (h."data" ? $2::TEXT AND h."data"->>$2::TEXT IS NOT NULL) b
|
||||
WHERE o."_key" = $1::TEXT
|
||||
LIMIT 1`,
|
||||
values: [key, field],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (res.rows.length) {
|
||||
return callback(null, res.rows[0].b);
|
||||
}
|
||||
|
||||
callback(null, false);
|
||||
});
|
||||
|
||||
return res.rows.length ? res.rows[0].b : false;
|
||||
};
|
||||
|
||||
module.isObjectFields = function (key, fields, callback) {
|
||||
module.isObjectFields = async function (key, fields) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
module.getObjectFields(key, fields, function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (!data) {
|
||||
return callback(null, fields.map(function () {
|
||||
return false;
|
||||
}));
|
||||
}
|
||||
|
||||
callback(null, fields.map(function (field) {
|
||||
return data.hasOwnProperty(field) && data[field] !== null;
|
||||
}));
|
||||
});
|
||||
const data = await module.getObjectFields(key, fields);
|
||||
if (!data) {
|
||||
return fields.map(() => false);
|
||||
}
|
||||
return fields.map(field => data.hasOwnProperty(field) && data[field] !== null);
|
||||
};
|
||||
|
||||
module.deleteObjectField = function (key, field, callback) {
|
||||
module.deleteObjectFields(key, [field], callback);
|
||||
module.deleteObjectField = async function (key, field) {
|
||||
await module.deleteObjectFields(key, [field]);
|
||||
};
|
||||
|
||||
module.deleteObjectFields = function (key, fields, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.deleteObjectFields = async function (key, fields) {
|
||||
if (!key || !Array.isArray(fields) || !fields.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
db.query({
|
||||
await db.query({
|
||||
name: 'deleteObjectFields',
|
||||
text: `
|
||||
UPDATE "legacy_hash"
|
||||
@@ -335,57 +246,52 @@ UPDATE "legacy_hash"
|
||||
WHERE "key" <> ALL ($2::TEXT[])), '{}')
|
||||
WHERE "_key" = $1::TEXT`,
|
||||
values: [key, fields],
|
||||
}, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
};
|
||||
|
||||
module.incrObjectField = function (key, field, callback) {
|
||||
module.incrObjectFieldBy(key, field, 1, callback);
|
||||
module.incrObjectField = async function (key, field) {
|
||||
return await module.incrObjectFieldBy(key, field, 1);
|
||||
};
|
||||
|
||||
module.decrObjectField = function (key, field, callback) {
|
||||
module.incrObjectFieldBy(key, field, -1, callback);
|
||||
module.decrObjectField = async function (key, field) {
|
||||
return await module.incrObjectFieldBy(key, field, -1);
|
||||
};
|
||||
|
||||
module.incrObjectFieldBy = function (key, field, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.incrObjectFieldBy = async function (key, field, value) {
|
||||
value = parseInt(value, 10);
|
||||
|
||||
if (!key || isNaN(value)) {
|
||||
return callback(null, null);
|
||||
return null;
|
||||
}
|
||||
|
||||
module.transaction(function (tx, done) {
|
||||
var query = tx.client.query.bind(tx.client);
|
||||
return await module.transaction(async function (client) {
|
||||
var query = client.query.bind(client);
|
||||
if (Array.isArray(key)) {
|
||||
await helpers.ensureLegacyObjectsType(client, key, 'hash');
|
||||
} else {
|
||||
await helpers.ensureLegacyObjectType(client, key, 'hash');
|
||||
}
|
||||
|
||||
async.waterfall([
|
||||
async.apply(Array.isArray(key) ? helpers.ensureLegacyObjectsType : helpers.ensureLegacyObjectType, tx.client, key, 'hash'),
|
||||
async.apply(query, Array.isArray(key) ? {
|
||||
name: 'incrObjectFieldByMulti',
|
||||
text: `
|
||||
const res = await query(Array.isArray(key) ? {
|
||||
name: 'incrObjectFieldByMulti',
|
||||
text: `
|
||||
INSERT INTO "legacy_hash" ("_key", "data")
|
||||
SELECT UNNEST($1::TEXT[]), jsonb_build_object($2::TEXT, $3::NUMERIC)
|
||||
ON CONFLICT ("_key")
|
||||
DO UPDATE SET "data" = jsonb_set("legacy_hash"."data", ARRAY[$2::TEXT], to_jsonb(COALESCE(("legacy_hash"."data"->>$2::TEXT)::NUMERIC, 0) + $3::NUMERIC))
|
||||
ON CONFLICT ("_key")
|
||||
DO UPDATE SET "data" = jsonb_set("legacy_hash"."data", ARRAY[$2::TEXT], to_jsonb(COALESCE(("legacy_hash"."data"->>$2::TEXT)::NUMERIC, 0) + $3::NUMERIC))
|
||||
RETURNING ("data"->>$2::TEXT)::NUMERIC v`,
|
||||
values: [key, field, value],
|
||||
} : {
|
||||
name: 'incrObjectFieldBy',
|
||||
text: `
|
||||
values: [key, field, value],
|
||||
} : {
|
||||
name: 'incrObjectFieldBy',
|
||||
text: `
|
||||
INSERT INTO "legacy_hash" ("_key", "data")
|
||||
VALUES ($1::TEXT, jsonb_build_object($2::TEXT, $3::NUMERIC))
|
||||
ON CONFLICT ("_key")
|
||||
DO UPDATE SET "data" = jsonb_set("legacy_hash"."data", ARRAY[$2::TEXT], to_jsonb(COALESCE(("legacy_hash"."data"->>$2::TEXT)::NUMERIC, 0) + $3::NUMERIC))
|
||||
ON CONFLICT ("_key")
|
||||
DO UPDATE SET "data" = jsonb_set("legacy_hash"."data", ARRAY[$2::TEXT], to_jsonb(COALESCE(("legacy_hash"."data"->>$2::TEXT)::NUMERIC, 0) + $3::NUMERIC))
|
||||
RETURNING ("data"->>$2::TEXT)::NUMERIC v`,
|
||||
values: [key, field, value],
|
||||
}),
|
||||
function (res, next) {
|
||||
next(null, Array.isArray(key) ? res.rows.map(function (r) {
|
||||
return parseFloat(r.v);
|
||||
}) : parseFloat(res.rows[0].v));
|
||||
},
|
||||
], done);
|
||||
}, callback);
|
||||
values: [key, field, value],
|
||||
});
|
||||
return Array.isArray(key) ? res.rows.map(r => parseFloat(r.v)) : parseFloat(res.rows[0].v);
|
||||
});
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
'use strict';
|
||||
|
||||
var helpers = {};
|
||||
var helpers = module.exports;
|
||||
|
||||
helpers.valueToString = function (value) {
|
||||
return String(value);
|
||||
@@ -19,117 +19,82 @@ helpers.removeDuplicateValues = function (values) {
|
||||
}
|
||||
};
|
||||
|
||||
helpers.ensureLegacyObjectType = function (db, key, type, callback) {
|
||||
db.query({
|
||||
helpers.ensureLegacyObjectType = async function (db, key, type) {
|
||||
await db.query({
|
||||
name: 'ensureLegacyObjectTypeBefore',
|
||||
text: `
|
||||
DELETE FROM "legacy_object"
|
||||
WHERE "expireAt" IS NOT NULL
|
||||
AND "expireAt" <= CURRENT_TIMESTAMP`,
|
||||
}, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
});
|
||||
|
||||
db.query({
|
||||
name: 'ensureLegacyObjectType1',
|
||||
text: `
|
||||
await db.query({
|
||||
name: 'ensureLegacyObjectType1',
|
||||
text: `
|
||||
INSERT INTO "legacy_object" ("_key", "type")
|
||||
VALUES ($1::TEXT, $2::TEXT::LEGACY_OBJECT_TYPE)
|
||||
ON CONFLICT
|
||||
DO NOTHING`,
|
||||
values: [key, type],
|
||||
}, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
values: [key, type],
|
||||
});
|
||||
|
||||
db.query({
|
||||
name: 'ensureLegacyObjectType2',
|
||||
text: `
|
||||
const res = await db.query({
|
||||
name: 'ensureLegacyObjectType2',
|
||||
text: `
|
||||
SELECT "type"
|
||||
FROM "legacy_object_live"
|
||||
WHERE "_key" = $1::TEXT`,
|
||||
values: [key],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (res.rows[0].type !== type) {
|
||||
return callback(new Error('database: cannot insert ' + JSON.stringify(key) + ' as ' + type + ' because it already exists as ' + res.rows[0].type));
|
||||
}
|
||||
|
||||
callback(null);
|
||||
});
|
||||
});
|
||||
values: [key],
|
||||
});
|
||||
|
||||
if (res.rows[0].type !== type) {
|
||||
throw new Error('database: cannot insert ' + JSON.stringify(key) + ' as ' + type + ' because it already exists as ' + res.rows[0].type);
|
||||
}
|
||||
};
|
||||
|
||||
helpers.ensureLegacyObjectsType = function (db, keys, type, callback) {
|
||||
db.query({
|
||||
helpers.ensureLegacyObjectsType = async function (db, keys, type) {
|
||||
await db.query({
|
||||
name: 'ensureLegacyObjectTypeBefore',
|
||||
text: `
|
||||
DELETE FROM "legacy_object"
|
||||
WHERE "expireAt" IS NOT NULL
|
||||
AND "expireAt" <= CURRENT_TIMESTAMP`,
|
||||
}, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
});
|
||||
|
||||
db.query({
|
||||
name: 'ensureLegacyObjectsType1',
|
||||
text: `
|
||||
await db.query({
|
||||
name: 'ensureLegacyObjectsType1',
|
||||
text: `
|
||||
INSERT INTO "legacy_object" ("_key", "type")
|
||||
SELECT k, $2::TEXT::LEGACY_OBJECT_TYPE
|
||||
FROM UNNEST($1::TEXT[]) k
|
||||
ON CONFLICT
|
||||
DO NOTHING`,
|
||||
values: [keys, type],
|
||||
}, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
values: [keys, type],
|
||||
});
|
||||
|
||||
db.query({
|
||||
name: 'ensureLegacyObjectsType2',
|
||||
text: `
|
||||
const res = await db.query({
|
||||
name: 'ensureLegacyObjectsType2',
|
||||
text: `
|
||||
SELECT "_key", "type"
|
||||
FROM "legacy_object_live"
|
||||
WHERE "_key" = ANY($1::TEXT[])`,
|
||||
values: [keys],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
var invalid = res.rows.filter(function (r) {
|
||||
return r.type !== type;
|
||||
});
|
||||
|
||||
if (invalid.length) {
|
||||
return callback(new Error('database: cannot insert multiple objects as ' + type + ' because they already exist: ' + invalid.map(function (r) {
|
||||
return JSON.stringify(r._key) + ' is ' + r.type;
|
||||
}).join(', ')));
|
||||
}
|
||||
|
||||
var missing = keys.filter(function (k) {
|
||||
return !res.rows.some(function (r) {
|
||||
return r._key === k;
|
||||
});
|
||||
});
|
||||
|
||||
if (missing.length) {
|
||||
return callback(new Error('database: failed to insert keys for objects: ' + JSON.stringify(missing)));
|
||||
}
|
||||
|
||||
callback(null);
|
||||
});
|
||||
});
|
||||
values: [keys],
|
||||
});
|
||||
|
||||
var invalid = res.rows.filter(r => r.type !== type);
|
||||
|
||||
if (invalid.length) {
|
||||
const parts = invalid.map(r => JSON.stringify(r._key) + ' is ' + r.type);
|
||||
throw new Error('database: cannot insert multiple objects as ' + type + ' because they already exist: ' + parts.join(', '));
|
||||
}
|
||||
|
||||
var missing = keys.filter(function (k) {
|
||||
return !res.rows.some(r => r._key === k);
|
||||
});
|
||||
|
||||
if (missing.length) {
|
||||
throw new Error('database: failed to insert keys for objects: ' + JSON.stringify(missing));
|
||||
}
|
||||
};
|
||||
|
||||
helpers.noop = function () {};
|
||||
|
||||
module.exports = helpers;
|
||||
|
||||
@@ -1,72 +1,54 @@
|
||||
'use strict';
|
||||
|
||||
var async = require('async');
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.postgres;
|
||||
|
||||
module.listPrepend = function (key, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
var helpers = require('./helpers');
|
||||
|
||||
module.listPrepend = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
module.transaction(function (tx, done) {
|
||||
var query = tx.client.query.bind(tx.client);
|
||||
|
||||
async.series([
|
||||
async.apply(helpers.ensureLegacyObjectType, tx.client, key, 'list'),
|
||||
async.apply(query, {
|
||||
name: 'listPrepend',
|
||||
text: `
|
||||
await module.transaction(async function (client) {
|
||||
var query = client.query.bind(client);
|
||||
await helpers.ensureLegacyObjectType(client, key, 'list');
|
||||
await query({
|
||||
name: 'listPrepend',
|
||||
text: `
|
||||
INSERT INTO "legacy_list" ("_key", "array")
|
||||
VALUES ($1::TEXT, ARRAY[$2::TEXT])
|
||||
ON CONFLICT ("_key")
|
||||
DO UPDATE SET "array" = ARRAY[$2::TEXT] || "legacy_list"."array"`,
|
||||
values: [key, value],
|
||||
}),
|
||||
], function (err) {
|
||||
done(err);
|
||||
ON CONFLICT ("_key")
|
||||
DO UPDATE SET "array" = ARRAY[$2::TEXT] || "legacy_list"."array"`,
|
||||
values: [key, value],
|
||||
});
|
||||
}, callback);
|
||||
});
|
||||
};
|
||||
|
||||
module.listAppend = function (key, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.listAppend = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
module.transaction(function (tx, done) {
|
||||
var query = tx.client.query.bind(tx.client);
|
||||
|
||||
async.series([
|
||||
async.apply(helpers.ensureLegacyObjectType, tx.client, key, 'list'),
|
||||
async.apply(query, {
|
||||
name: 'listAppend',
|
||||
text: `
|
||||
await module.transaction(async function (client) {
|
||||
var query = client.query.bind(client);
|
||||
await helpers.ensureLegacyObjectType(client, key, 'list');
|
||||
await query({
|
||||
name: 'listAppend',
|
||||
text: `
|
||||
INSERT INTO "legacy_list" ("_key", "array")
|
||||
VALUES ($1::TEXT, ARRAY[$2::TEXT])
|
||||
ON CONFLICT ("_key")
|
||||
DO UPDATE SET "array" = "legacy_list"."array" || ARRAY[$2::TEXT]`,
|
||||
values: [key, value],
|
||||
}),
|
||||
], function (err) {
|
||||
done(err);
|
||||
ON CONFLICT ("_key")
|
||||
DO UPDATE SET "array" = "legacy_list"."array" || ARRAY[$2::TEXT]`,
|
||||
values: [key, value],
|
||||
});
|
||||
}, callback || helpers.noop);
|
||||
});
|
||||
};
|
||||
|
||||
module.listRemoveLast = function (key, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.listRemoveLast = async function (key) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
db.query({
|
||||
const res = await db.query({
|
||||
name: 'listRemoveLast',
|
||||
text: `
|
||||
WITH A AS (
|
||||
@@ -83,27 +65,17 @@ UPDATE "legacy_list" l
|
||||
WHERE A."_key" = l."_key"
|
||||
RETURNING A."array"[array_length(A."array", 1)] v`,
|
||||
values: [key],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (res.rows.length) {
|
||||
return callback(null, res.rows[0].v);
|
||||
}
|
||||
|
||||
callback(null, null);
|
||||
});
|
||||
|
||||
return res.rows.length ? res.rows[0].v : null;
|
||||
};
|
||||
|
||||
module.listRemoveAll = function (key, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.listRemoveAll = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
db.query({
|
||||
await db.query({
|
||||
name: 'listRemoveAll',
|
||||
text: `
|
||||
UPDATE "legacy_list" l
|
||||
@@ -113,21 +85,17 @@ UPDATE "legacy_list" l
|
||||
AND o."type" = l."type"
|
||||
AND o."_key" = $1::TEXT`,
|
||||
values: [key, value],
|
||||
}, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
};
|
||||
|
||||
module.listTrim = function (key, start, stop, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.listTrim = async function (key, start, stop) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
stop += 1;
|
||||
|
||||
db.query(stop > 0 ? {
|
||||
await db.query(stop > 0 ? {
|
||||
name: 'listTrim',
|
||||
text: `
|
||||
UPDATE "legacy_list" l
|
||||
@@ -155,19 +123,17 @@ UPDATE "legacy_list" l
|
||||
AND o."type" = l."type"
|
||||
AND o."_key" = $1::TEXT`,
|
||||
values: [key, start, stop],
|
||||
}, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
};
|
||||
|
||||
module.getListRange = function (key, start, stop, callback) {
|
||||
module.getListRange = async function (key, start, stop) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
stop += 1;
|
||||
|
||||
db.query(stop > 0 ? {
|
||||
const res = await db.query(stop > 0 ? {
|
||||
name: 'getListRange',
|
||||
text: `
|
||||
SELECT ARRAY(SELECT m.m
|
||||
@@ -195,21 +161,13 @@ SELECT ARRAY(SELECT m.m
|
||||
AND o."type" = l."type"
|
||||
WHERE o."_key" = $1::TEXT`,
|
||||
values: [key, start, stop],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (res.rows.length) {
|
||||
return callback(null, res.rows[0].l);
|
||||
}
|
||||
|
||||
callback(null, []);
|
||||
});
|
||||
|
||||
return res.rows.length ? res.rows[0].l : [];
|
||||
};
|
||||
|
||||
module.listLength = function (key, callback) {
|
||||
db.query({
|
||||
module.listLength = async function (key) {
|
||||
const res = await db.query({
|
||||
name: 'listLength',
|
||||
text: `
|
||||
SELECT array_length(l."array", 1) l
|
||||
@@ -219,16 +177,8 @@ SELECT array_length(l."array", 1) l
|
||||
AND o."type" = l."type"
|
||||
WHERE o."_key" = $1::TEXT`,
|
||||
values: [key],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (res.rows.length) {
|
||||
return callback(null, res.rows[0].l);
|
||||
}
|
||||
|
||||
callback(null, 0);
|
||||
});
|
||||
|
||||
return res.rows.length ? res.rows[0].l : 0;
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,114 +1,83 @@
|
||||
'use strict';
|
||||
|
||||
var async = require('async');
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.postgres;
|
||||
var helpers = require('./helpers');
|
||||
|
||||
var query = db.query.bind(db);
|
||||
|
||||
module.flushdb = function (callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
async.series([
|
||||
async.apply(query, `DROP SCHEMA "public" CASCADE`),
|
||||
async.apply(query, `CREATE SCHEMA "public"`),
|
||||
], function (err) {
|
||||
callback(err);
|
||||
});
|
||||
module.flushdb = async function () {
|
||||
await query(`DROP SCHEMA "public" CASCADE`);
|
||||
await query(`CREATE SCHEMA "public"`);
|
||||
};
|
||||
|
||||
module.emptydb = function (callback) {
|
||||
callback = callback || helpers.noop;
|
||||
query(`DELETE FROM "legacy_object"`, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
module.emptydb = async function () {
|
||||
await query(`DELETE FROM "legacy_object"`);
|
||||
};
|
||||
|
||||
module.exists = function (key, callback) {
|
||||
module.exists = async function (key) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
if (Array.isArray(key)) {
|
||||
query({
|
||||
const res = await query({
|
||||
name: 'existsArray',
|
||||
text: `
|
||||
SELECT o."_key" k
|
||||
FROM "legacy_object_live" o
|
||||
WHERE o."_key" = ANY($1::TEXT[])`,
|
||||
values: [key],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
callback(null, key.map(function (k) {
|
||||
return res.rows.some(function (r) {
|
||||
return r.k === k;
|
||||
});
|
||||
}));
|
||||
});
|
||||
} else {
|
||||
query({
|
||||
name: 'exists',
|
||||
text: `
|
||||
SELECT EXISTS(SELECT *
|
||||
return key.map(function (k) {
|
||||
return res.rows.some(r => r.k === k);
|
||||
});
|
||||
}
|
||||
const res = await query({
|
||||
name: 'exists',
|
||||
text: `
|
||||
SELECT EXISTS(SELECT *
|
||||
FROM "legacy_object_live"
|
||||
WHERE "_key" = $1::TEXT
|
||||
LIMIT 1) e`,
|
||||
values: [key],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
callback(null, res.rows[0].e);
|
||||
});
|
||||
}
|
||||
values: [key],
|
||||
});
|
||||
return res.rows[0].e;
|
||||
};
|
||||
|
||||
module.delete = function (key, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.delete = async function (key) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
query({
|
||||
await query({
|
||||
name: 'delete',
|
||||
text: `
|
||||
DELETE FROM "legacy_object"
|
||||
WHERE "_key" = $1::TEXT`,
|
||||
values: [key],
|
||||
}, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
};
|
||||
|
||||
module.deleteAll = function (keys, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.deleteAll = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
query({
|
||||
await query({
|
||||
name: 'deleteAll',
|
||||
text: `
|
||||
DELETE FROM "legacy_object"
|
||||
WHERE "_key" = ANY($1::TEXT[])`,
|
||||
values: [keys],
|
||||
}, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
};
|
||||
|
||||
module.get = function (key, callback) {
|
||||
module.get = async function (key) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
query({
|
||||
const res = await query({
|
||||
name: 'get',
|
||||
text: `
|
||||
SELECT s."data" t
|
||||
@@ -119,94 +88,76 @@ SELECT s."data" t
|
||||
WHERE o."_key" = $1::TEXT
|
||||
LIMIT 1`,
|
||||
values: [key],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
});
|
||||
|
||||
if (res.rows.length) {
|
||||
return callback(null, res.rows[0].t);
|
||||
}
|
||||
return res.rows.length ? res.rows[0].t : null;
|
||||
};
|
||||
|
||||
callback(null, null);
|
||||
module.set = async function (key, value) {
|
||||
if (!key) {
|
||||
return;
|
||||
}
|
||||
|
||||
await module.transaction(async function (client) {
|
||||
var query = client.query.bind(client);
|
||||
await helpers.ensureLegacyObjectType(client, key, 'string');
|
||||
await query({
|
||||
name: 'set',
|
||||
text: `
|
||||
INSERT INTO "legacy_string" ("_key", "data")
|
||||
VALUES ($1::TEXT, $2::TEXT)
|
||||
ON CONFLICT ("_key")
|
||||
DO UPDATE SET "data" = $2::TEXT`,
|
||||
values: [key, value],
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
module.set = function (key, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.increment = async function (key) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
module.transaction(function (tx, done) {
|
||||
async.series([
|
||||
async.apply(helpers.ensureLegacyObjectType, tx.client, key, 'string'),
|
||||
async.apply(tx.client.query.bind(tx.client), {
|
||||
name: 'set',
|
||||
text: `
|
||||
INSERT INTO "legacy_string" ("_key", "data")
|
||||
VALUES ($1::TEXT, $2::TEXT)
|
||||
ON CONFLICT ("_key")
|
||||
DO UPDATE SET "data" = $2::TEXT`,
|
||||
values: [key, value],
|
||||
}),
|
||||
], function (err) {
|
||||
done(err);
|
||||
});
|
||||
}, callback);
|
||||
};
|
||||
|
||||
module.increment = function (key, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
if (!key) {
|
||||
return callback();
|
||||
}
|
||||
|
||||
module.transaction(function (tx, done) {
|
||||
async.waterfall([
|
||||
async.apply(helpers.ensureLegacyObjectType, tx.client, key, 'string'),
|
||||
async.apply(tx.client.query.bind(tx.client), {
|
||||
name: 'increment',
|
||||
text: `
|
||||
return await module.transaction(async function (client) {
|
||||
var query = client.query.bind(client);
|
||||
await helpers.ensureLegacyObjectType(client, key, 'string');
|
||||
const res = await query({
|
||||
name: 'increment',
|
||||
text: `
|
||||
INSERT INTO "legacy_string" ("_key", "data")
|
||||
VALUES ($1::TEXT, '1')
|
||||
ON CONFLICT ("_key")
|
||||
DO UPDATE SET "data" = ("legacy_string"."data"::NUMERIC + 1)::TEXT
|
||||
ON CONFLICT ("_key")
|
||||
DO UPDATE SET "data" = ("legacy_string"."data"::NUMERIC + 1)::TEXT
|
||||
RETURNING "data" d`,
|
||||
values: [key],
|
||||
}),
|
||||
], function (err, res) {
|
||||
if (err) {
|
||||
return done(err);
|
||||
}
|
||||
|
||||
done(null, parseFloat(res.rows[0].d));
|
||||
values: [key],
|
||||
});
|
||||
}, callback);
|
||||
return parseFloat(res.rows[0].d);
|
||||
});
|
||||
};
|
||||
|
||||
module.rename = function (oldKey, newKey, callback) {
|
||||
module.transaction(function (tx, done) {
|
||||
async.series([
|
||||
async.apply(tx.delete, newKey),
|
||||
async.apply(tx.client.query.bind(tx.client), {
|
||||
name: 'rename',
|
||||
text: `
|
||||
module.rename = async function (oldKey, newKey) {
|
||||
await module.transaction(async function (client) {
|
||||
var query = client.query.bind(client);
|
||||
await query({
|
||||
name: 'deleteRename',
|
||||
text: `
|
||||
DELETE FROM "legacy_object"
|
||||
WHERE "_key" = $1::TEXT`,
|
||||
values: [newKey],
|
||||
});
|
||||
await query({
|
||||
name: 'rename',
|
||||
text: `
|
||||
UPDATE "legacy_object"
|
||||
SET "_key" = $2::TEXT
|
||||
WHERE "_key" = $1::TEXT`,
|
||||
values: [oldKey, newKey],
|
||||
}),
|
||||
], function (err) {
|
||||
done(err);
|
||||
SET "_key" = $2::TEXT
|
||||
WHERE "_key" = $1::TEXT`,
|
||||
values: [oldKey, newKey],
|
||||
});
|
||||
}, callback || helpers.noop);
|
||||
});
|
||||
};
|
||||
|
||||
module.type = function (key, callback) {
|
||||
query({
|
||||
module.type = async function (key) {
|
||||
const res = await query({
|
||||
name: 'type',
|
||||
text: `
|
||||
SELECT "type"::TEXT t
|
||||
@@ -214,47 +165,35 @@ SELECT "type"::TEXT t
|
||||
WHERE "_key" = $1::TEXT
|
||||
LIMIT 1`,
|
||||
values: [key],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (res.rows.length) {
|
||||
return callback(null, res.rows[0].t);
|
||||
}
|
||||
|
||||
callback(null, null);
|
||||
});
|
||||
|
||||
return res.rows.length ? res.rows[0].t : null;
|
||||
};
|
||||
|
||||
function doExpire(key, date, callback) {
|
||||
query({
|
||||
async function doExpire(key, date) {
|
||||
await query({
|
||||
name: 'expire',
|
||||
text: `
|
||||
UPDATE "legacy_object"
|
||||
SET "expireAt" = $2::TIMESTAMPTZ
|
||||
WHERE "_key" = $1::TEXT`,
|
||||
values: [key, date],
|
||||
}, function (err) {
|
||||
if (callback) {
|
||||
callback(err);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
module.expire = function (key, seconds, callback) {
|
||||
doExpire(key, new Date(((Date.now() / 1000) + seconds) * 1000), callback);
|
||||
module.expire = async function (key, seconds) {
|
||||
await doExpire(key, new Date(((Date.now() / 1000) + seconds) * 1000));
|
||||
};
|
||||
|
||||
module.expireAt = function (key, timestamp, callback) {
|
||||
doExpire(key, new Date(timestamp * 1000), callback);
|
||||
module.expireAt = async function (key, timestamp) {
|
||||
await doExpire(key, new Date(timestamp * 1000));
|
||||
};
|
||||
|
||||
module.pexpire = function (key, ms, callback) {
|
||||
doExpire(key, new Date(Date.now() + parseInt(ms, 10)), callback);
|
||||
module.pexpire = async function (key, ms) {
|
||||
await doExpire(key, new Date(Date.now() + parseInt(ms, 10)));
|
||||
};
|
||||
|
||||
module.pexpireAt = function (key, timestamp, callback) {
|
||||
doExpire(key, new Date(timestamp), callback);
|
||||
module.pexpireAt = async function (key, timestamp) {
|
||||
await doExpire(key, new Date(timestamp));
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,44 +1,34 @@
|
||||
'use strict';
|
||||
|
||||
var async = require('async');
|
||||
var _ = require('lodash');
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.postgres;
|
||||
|
||||
module.setAdd = function (key, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
var helpers = require('./helpers');
|
||||
|
||||
module.setAdd = async function (key, value) {
|
||||
if (!Array.isArray(value)) {
|
||||
value = [value];
|
||||
}
|
||||
|
||||
module.transaction(function (tx, done) {
|
||||
var query = tx.client.query.bind(tx.client);
|
||||
|
||||
async.series([
|
||||
async.apply(helpers.ensureLegacyObjectType, tx.client, key, 'set'),
|
||||
async.apply(query, {
|
||||
name: 'setAdd',
|
||||
text: `
|
||||
await module.transaction(async function (client) {
|
||||
var query = client.query.bind(client);
|
||||
await helpers.ensureLegacyObjectType(client, key, 'set');
|
||||
await query({
|
||||
name: 'setAdd',
|
||||
text: `
|
||||
INSERT INTO "legacy_set" ("_key", "member")
|
||||
SELECT $1::TEXT, m
|
||||
FROM UNNEST($2::TEXT[]) m
|
||||
ON CONFLICT ("_key", "member")
|
||||
DO NOTHING`,
|
||||
values: [key, value],
|
||||
}),
|
||||
], function (err) {
|
||||
done(err);
|
||||
FROM UNNEST($2::TEXT[]) m
|
||||
ON CONFLICT ("_key", "member")
|
||||
DO NOTHING`,
|
||||
values: [key, value],
|
||||
});
|
||||
}, callback);
|
||||
});
|
||||
};
|
||||
|
||||
module.setsAdd = function (keys, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.setsAdd = async function (keys, value) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
if (!Array.isArray(value)) {
|
||||
@@ -47,31 +37,24 @@ SELECT $1::TEXT, m
|
||||
|
||||
keys = _.uniq(keys);
|
||||
|
||||
module.transaction(function (tx, done) {
|
||||
var query = tx.client.query.bind(tx.client);
|
||||
|
||||
async.series([
|
||||
async.apply(helpers.ensureLegacyObjectsType, tx.client, keys, 'set'),
|
||||
async.apply(query, {
|
||||
name: 'setsAdd',
|
||||
text: `
|
||||
await module.transaction(async function (client) {
|
||||
var query = client.query.bind(client);
|
||||
await helpers.ensureLegacyObjectsType(client, keys, 'set');
|
||||
await query({
|
||||
name: 'setsAdd',
|
||||
text: `
|
||||
INSERT INTO "legacy_set" ("_key", "member")
|
||||
SELECT k, m
|
||||
FROM UNNEST($1::TEXT[]) k
|
||||
CROSS JOIN UNNEST($2::TEXT[]) m
|
||||
ON CONFLICT ("_key", "member")
|
||||
DO NOTHING`,
|
||||
values: [keys, value],
|
||||
}),
|
||||
], function (err) {
|
||||
done(err);
|
||||
FROM UNNEST($1::TEXT[]) k
|
||||
CROSS JOIN UNNEST($2::TEXT[]) m
|
||||
ON CONFLICT ("_key", "member")
|
||||
DO NOTHING`,
|
||||
values: [keys, value],
|
||||
});
|
||||
}, callback);
|
||||
});
|
||||
};
|
||||
|
||||
module.setRemove = function (key, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.setRemove = async function (key, value) {
|
||||
if (!Array.isArray(key)) {
|
||||
key = [key];
|
||||
}
|
||||
@@ -80,43 +63,37 @@ SELECT k, m
|
||||
value = [value];
|
||||
}
|
||||
|
||||
db.query({
|
||||
await db.query({
|
||||
name: 'setRemove',
|
||||
text: `
|
||||
DELETE FROM "legacy_set"
|
||||
WHERE "_key" = ANY($1::TEXT[])
|
||||
AND "member" = ANY($2::TEXT[])`,
|
||||
values: [key, value],
|
||||
}, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
};
|
||||
|
||||
module.setsRemove = function (keys, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.setsRemove = async function (keys, value) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
db.query({
|
||||
await db.query({
|
||||
name: 'setsRemove',
|
||||
text: `
|
||||
DELETE FROM "legacy_set"
|
||||
WHERE "_key" = ANY($1::TEXT[])
|
||||
AND "member" = $2::TEXT`,
|
||||
values: [keys, value],
|
||||
}, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
};
|
||||
|
||||
module.isSetMember = function (key, value, callback) {
|
||||
module.isSetMember = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback(null, false);
|
||||
return false;
|
||||
}
|
||||
|
||||
db.query({
|
||||
const res = await db.query({
|
||||
name: 'isSetMember',
|
||||
text: `
|
||||
SELECT 1
|
||||
@@ -127,23 +104,19 @@ SELECT 1
|
||||
WHERE o."_key" = $1::TEXT
|
||||
AND s."member" = $2::TEXT`,
|
||||
values: [key, value],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
callback(null, !!res.rows.length);
|
||||
});
|
||||
|
||||
return !!res.rows.length;
|
||||
};
|
||||
|
||||
module.isSetMembers = function (key, values, callback) {
|
||||
module.isSetMembers = async function (key, values) {
|
||||
if (!key || !Array.isArray(values) || !values.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
|
||||
values = values.map(helpers.valueToString);
|
||||
|
||||
db.query({
|
||||
const res = await db.query({
|
||||
name: 'isSetMembers',
|
||||
text: `
|
||||
SELECT s."member" m
|
||||
@@ -154,27 +127,21 @@ SELECT s."member" m
|
||||
WHERE o."_key" = $1::TEXT
|
||||
AND s."member" = ANY($2::TEXT[])`,
|
||||
values: [key, values],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
});
|
||||
|
||||
callback(null, values.map(function (v) {
|
||||
return res.rows.some(function (r) {
|
||||
return r.m === v;
|
||||
});
|
||||
}));
|
||||
return values.map(function (v) {
|
||||
return res.rows.some(r => r.m === v);
|
||||
});
|
||||
};
|
||||
|
||||
module.isMemberOfSets = function (sets, value, callback) {
|
||||
module.isMemberOfSets = async function (sets, value) {
|
||||
if (!Array.isArray(sets) || !sets.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
db.query({
|
||||
const res = await db.query({
|
||||
name: 'isMemberOfSets',
|
||||
text: `
|
||||
SELECT o."_key" k
|
||||
@@ -185,25 +152,19 @@ SELECT o."_key" k
|
||||
WHERE o."_key" = ANY($1::TEXT[])
|
||||
AND s."member" = $2::TEXT`,
|
||||
values: [sets, value],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
});
|
||||
|
||||
callback(null, sets.map(function (s) {
|
||||
return res.rows.some(function (r) {
|
||||
return r.k === s;
|
||||
});
|
||||
}));
|
||||
return sets.map(function (s) {
|
||||
return res.rows.some(r => r.k === s);
|
||||
});
|
||||
};
|
||||
|
||||
module.getSetMembers = function (key, callback) {
|
||||
module.getSetMembers = async function (key) {
|
||||
if (!key) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
|
||||
db.query({
|
||||
const res = await db.query({
|
||||
name: 'getSetMembers',
|
||||
text: `
|
||||
SELECT s."member" m
|
||||
@@ -213,23 +174,17 @@ SELECT s."member" m
|
||||
AND o."type" = s."type"
|
||||
WHERE o."_key" = $1::TEXT`,
|
||||
values: [key],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
callback(null, res.rows.map(function (r) {
|
||||
return r.m;
|
||||
}));
|
||||
});
|
||||
|
||||
return res.rows.map(r => r.m);
|
||||
};
|
||||
|
||||
module.getSetsMembers = function (keys, callback) {
|
||||
module.getSetsMembers = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
|
||||
db.query({
|
||||
const res = await db.query({
|
||||
name: 'getSetsMembers',
|
||||
text: `
|
||||
SELECT o."_key" k,
|
||||
@@ -241,25 +196,19 @@ SELECT o."_key" k,
|
||||
WHERE o."_key" = ANY($1::TEXT[])
|
||||
GROUP BY o."_key"`,
|
||||
values: [keys],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
});
|
||||
|
||||
callback(null, keys.map(function (k) {
|
||||
return (res.rows.find(function (r) {
|
||||
return r.k === k;
|
||||
}) || { m: [] }).m;
|
||||
}));
|
||||
return keys.map(function (k) {
|
||||
return (res.rows.find(r => r.k === k) || { m: [] }).m;
|
||||
});
|
||||
};
|
||||
|
||||
module.setCount = function (key, callback) {
|
||||
module.setCount = async function (key) {
|
||||
if (!key) {
|
||||
return callback(null, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
db.query({
|
||||
const res = await db.query({
|
||||
name: 'setCount',
|
||||
text: `
|
||||
SELECT COUNT(*) c
|
||||
@@ -269,17 +218,13 @@ SELECT COUNT(*) c
|
||||
AND o."type" = s."type"
|
||||
WHERE o."_key" = $1::TEXT`,
|
||||
values: [key],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
callback(null, parseInt(res.rows[0].c, 10));
|
||||
});
|
||||
|
||||
return parseInt(res.rows[0].c, 10);
|
||||
};
|
||||
|
||||
module.setsCount = function (keys, callback) {
|
||||
db.query({
|
||||
module.setsCount = async function (keys) {
|
||||
const res = await db.query({
|
||||
name: 'setsCount',
|
||||
text: `
|
||||
SELECT o."_key" k,
|
||||
@@ -291,23 +236,15 @@ SELECT o."_key" k,
|
||||
WHERE o."_key" = ANY($1::TEXT[])
|
||||
GROUP BY o."_key"`,
|
||||
values: [keys],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
});
|
||||
|
||||
callback(null, keys.map(function (k) {
|
||||
return (res.rows.find(function (r) {
|
||||
return r.k === k;
|
||||
}) || { c: 0 }).c;
|
||||
}));
|
||||
return keys.map(function (k) {
|
||||
return (res.rows.find(r => r.k === k) || { c: 0 }).c;
|
||||
});
|
||||
};
|
||||
|
||||
module.setRemoveRandom = function (key, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
db.query({
|
||||
module.setRemoveRandom = async function (key) {
|
||||
const res = await db.query({
|
||||
name: 'setRemoveRandom',
|
||||
text: `
|
||||
WITH A AS (
|
||||
@@ -326,16 +263,7 @@ DELETE FROM "legacy_set" s
|
||||
AND s."member" = A."member"
|
||||
RETURNING A."member" m`,
|
||||
values: [key],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (res.rows.length) {
|
||||
return callback(null, res.rows[0].m);
|
||||
}
|
||||
|
||||
callback(null, null);
|
||||
});
|
||||
return res.rows.length ? res.rows[0].m : null;
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,9 +1,11 @@
|
||||
'use strict';
|
||||
|
||||
var async = require('async');
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.postgres;
|
||||
var helpers = require('./helpers');
|
||||
const util = require('util');
|
||||
var Cursor = require('pg-cursor');
|
||||
Cursor.prototype.readAsync = util.promisify(Cursor.prototype.read);
|
||||
const sleep = util.promisify(setTimeout);
|
||||
|
||||
var query = db.query.bind(db);
|
||||
|
||||
@@ -12,25 +14,25 @@ module.exports = function (db, module) {
|
||||
require('./sorted/union')(db, module);
|
||||
require('./sorted/intersect')(db, module);
|
||||
|
||||
module.getSortedSetRange = function (key, start, stop, callback) {
|
||||
getSortedSetRange(key, start, stop, 1, false, callback);
|
||||
module.getSortedSetRange = async function (key, start, stop) {
|
||||
return await getSortedSetRange(key, start, stop, 1, false);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRange = function (key, start, stop, callback) {
|
||||
getSortedSetRange(key, start, stop, -1, false, callback);
|
||||
module.getSortedSetRevRange = async function (key, start, stop) {
|
||||
return await getSortedSetRange(key, start, stop, -1, false);
|
||||
};
|
||||
|
||||
module.getSortedSetRangeWithScores = function (key, start, stop, callback) {
|
||||
getSortedSetRange(key, start, stop, 1, true, callback);
|
||||
module.getSortedSetRangeWithScores = async function (key, start, stop) {
|
||||
return await getSortedSetRange(key, start, stop, 1, true);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRangeWithScores = function (key, start, stop, callback) {
|
||||
getSortedSetRange(key, start, stop, -1, true, callback);
|
||||
module.getSortedSetRevRangeWithScores = async function (key, start, stop) {
|
||||
return await getSortedSetRange(key, start, stop, -1, true);
|
||||
};
|
||||
|
||||
function getSortedSetRange(key, start, stop, sort, withScores, callback) {
|
||||
async function getSortedSetRange(key, start, stop, sort, withScores) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
if (!Array.isArray(key)) {
|
||||
@@ -38,7 +40,7 @@ module.exports = function (db, module) {
|
||||
}
|
||||
|
||||
if (start < 0 && start > stop) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
|
||||
var reverse = false;
|
||||
@@ -58,7 +60,7 @@ module.exports = function (db, module) {
|
||||
limit = null;
|
||||
}
|
||||
|
||||
query({
|
||||
const res = await query({
|
||||
name: 'getSortedSetRangeWithScores' + (sort > 0 ? 'Asc' : 'Desc'),
|
||||
text: `
|
||||
SELECT z."value",
|
||||
@@ -72,51 +74,40 @@ SELECT z."value",
|
||||
LIMIT $3::INTEGER
|
||||
OFFSET $2::INTEGER`,
|
||||
values: [key, start, limit],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (reverse) {
|
||||
res.rows.reverse();
|
||||
}
|
||||
|
||||
if (withScores) {
|
||||
res.rows = res.rows.map(function (r) {
|
||||
return {
|
||||
value: r.value,
|
||||
score: parseFloat(r.score),
|
||||
};
|
||||
});
|
||||
} else {
|
||||
res.rows = res.rows.map(function (r) {
|
||||
return r.value;
|
||||
});
|
||||
}
|
||||
|
||||
callback(null, res.rows);
|
||||
});
|
||||
|
||||
if (reverse) {
|
||||
res.rows.reverse();
|
||||
}
|
||||
|
||||
if (withScores) {
|
||||
res.rows = res.rows.map(r => ({ value: r.value, score: parseFloat(r.score) }));
|
||||
} else {
|
||||
res.rows = res.rows.map(r => r.value);
|
||||
}
|
||||
|
||||
return res.rows;
|
||||
}
|
||||
|
||||
module.getSortedSetRangeByScore = function (key, start, count, min, max, callback) {
|
||||
getSortedSetRangeByScore(key, start, count, min, max, 1, false, callback);
|
||||
module.getSortedSetRangeByScore = async function (key, start, count, min, max) {
|
||||
return await getSortedSetRangeByScore(key, start, count, min, max, 1, false);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRangeByScore = function (key, start, count, max, min, callback) {
|
||||
getSortedSetRangeByScore(key, start, count, min, max, -1, false, callback);
|
||||
module.getSortedSetRevRangeByScore = async function (key, start, count, max, min) {
|
||||
return await getSortedSetRangeByScore(key, start, count, min, max, -1, false);
|
||||
};
|
||||
|
||||
module.getSortedSetRangeByScoreWithScores = function (key, start, count, min, max, callback) {
|
||||
getSortedSetRangeByScore(key, start, count, min, max, 1, true, callback);
|
||||
module.getSortedSetRangeByScoreWithScores = async function (key, start, count, min, max) {
|
||||
return await getSortedSetRangeByScore(key, start, count, min, max, 1, true);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRangeByScoreWithScores = function (key, start, count, max, min, callback) {
|
||||
getSortedSetRangeByScore(key, start, count, min, max, -1, true, callback);
|
||||
module.getSortedSetRevRangeByScoreWithScores = async function (key, start, count, max, min) {
|
||||
return await getSortedSetRangeByScore(key, start, count, min, max, -1, true);
|
||||
};
|
||||
|
||||
function getSortedSetRangeByScore(key, start, count, min, max, sort, withScores, callback) {
|
||||
async function getSortedSetRangeByScore(key, start, count, min, max, sort, withScores) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
if (!Array.isArray(key)) {
|
||||
@@ -134,7 +125,7 @@ OFFSET $2::INTEGER`,
|
||||
max = null;
|
||||
}
|
||||
|
||||
query({
|
||||
const res = await query({
|
||||
name: 'getSortedSetRangeByScoreWithScores' + (sort > 0 ? 'Asc' : 'Desc'),
|
||||
text: `
|
||||
SELECT z."value",
|
||||
@@ -150,31 +141,20 @@ SELECT z."value",
|
||||
LIMIT $3::INTEGER
|
||||
OFFSET $2::INTEGER`,
|
||||
values: [key, start, count, min, max],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (withScores) {
|
||||
res.rows = res.rows.map(function (r) {
|
||||
return {
|
||||
value: r.value,
|
||||
score: parseFloat(r.score),
|
||||
};
|
||||
});
|
||||
} else {
|
||||
res.rows = res.rows.map(function (r) {
|
||||
return r.value;
|
||||
});
|
||||
}
|
||||
|
||||
return callback(null, res.rows);
|
||||
});
|
||||
|
||||
if (withScores) {
|
||||
res.rows = res.rows.map(r => ({ value: r.value, score: parseFloat(r.score) }));
|
||||
} else {
|
||||
res.rows = res.rows.map(r => r.value);
|
||||
}
|
||||
|
||||
return res.rows;
|
||||
}
|
||||
|
||||
module.sortedSetCount = function (key, min, max, callback) {
|
||||
module.sortedSetCount = async function (key, min, max) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
if (min === '-inf') {
|
||||
@@ -184,7 +164,7 @@ OFFSET $2::INTEGER`,
|
||||
max = null;
|
||||
}
|
||||
|
||||
query({
|
||||
const res = await query({
|
||||
name: 'sortedSetCount',
|
||||
text: `
|
||||
SELECT COUNT(*) c
|
||||
@@ -196,21 +176,17 @@ SELECT COUNT(*) c
|
||||
AND (z."score" >= $2::NUMERIC OR $2::NUMERIC IS NULL)
|
||||
AND (z."score" <= $3::NUMERIC OR $3::NUMERIC IS NULL)`,
|
||||
values: [key, min, max],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
callback(null, parseInt(res.rows[0].c, 10));
|
||||
});
|
||||
|
||||
return parseInt(res.rows[0].c, 10);
|
||||
};
|
||||
|
||||
module.sortedSetCard = function (key, callback) {
|
||||
module.sortedSetCard = async function (key) {
|
||||
if (!key) {
|
||||
return callback(null, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
query({
|
||||
const res = await query({
|
||||
name: 'sortedSetCard',
|
||||
text: `
|
||||
SELECT COUNT(*) c
|
||||
@@ -220,21 +196,17 @@ SELECT COUNT(*) c
|
||||
AND o."type" = z."type"
|
||||
WHERE o."_key" = $1::TEXT`,
|
||||
values: [key],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
callback(null, parseInt(res.rows[0].c, 10));
|
||||
});
|
||||
|
||||
return parseInt(res.rows[0].c, 10);
|
||||
};
|
||||
|
||||
module.sortedSetsCard = function (keys, callback) {
|
||||
module.sortedSetsCard = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
|
||||
query({
|
||||
const res = await query({
|
||||
name: 'sortedSetsCard',
|
||||
text: `
|
||||
SELECT o."_key" k,
|
||||
@@ -246,50 +218,38 @@ SELECT o."_key" k,
|
||||
WHERE o."_key" = ANY($1::TEXT[])
|
||||
GROUP BY o."_key"`,
|
||||
values: [keys],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
});
|
||||
|
||||
callback(null, keys.map(function (k) {
|
||||
return parseInt((res.rows.find(function (r) {
|
||||
return r.k === k;
|
||||
}) || { c: 0 }).c, 10);
|
||||
}));
|
||||
return keys.map(function (k) {
|
||||
return parseInt((res.rows.find(r => r.k === k) || { c: 0 }).c, 10);
|
||||
});
|
||||
};
|
||||
|
||||
module.sortedSetsCardSum = function (keys, callback) {
|
||||
module.sortedSetsCardSum = async function (keys) {
|
||||
if (!keys || (Array.isArray(keys) && !keys.length)) {
|
||||
return callback(null, 0);
|
||||
return 0;
|
||||
}
|
||||
if (!Array.isArray(keys)) {
|
||||
keys = [keys];
|
||||
}
|
||||
module.sortedSetsCard(keys, function (err, counts) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
const sum = counts.reduce(function (acc, val) { return acc + val; }, 0);
|
||||
callback(null, sum);
|
||||
});
|
||||
const counts = await module.sortedSetsCard(keys);
|
||||
const sum = counts.reduce((acc, val) => acc + val, 0);
|
||||
return sum;
|
||||
};
|
||||
|
||||
module.sortedSetRank = function (key, value, callback) {
|
||||
getSortedSetRank('ASC', [key], [value], function (err, result) {
|
||||
callback(err, result ? result[0] : null);
|
||||
});
|
||||
module.sortedSetRank = async function (key, value) {
|
||||
const result = await getSortedSetRank('ASC', [key], [value]);
|
||||
return result ? result[0] : null;
|
||||
};
|
||||
|
||||
module.sortedSetRevRank = function (key, value, callback) {
|
||||
getSortedSetRank('DESC', [key], [value], function (err, result) {
|
||||
callback(err, result ? result[0] : null);
|
||||
});
|
||||
module.sortedSetRevRank = async function (key, value) {
|
||||
const result = await getSortedSetRank('DESC', [key], [value]);
|
||||
return result ? result[0] : null;
|
||||
};
|
||||
|
||||
function getSortedSetRank(sort, keys, values, callback) {
|
||||
async function getSortedSetRank(sort, keys, values) {
|
||||
values = values.map(helpers.valueToString);
|
||||
query({
|
||||
const res = await query({
|
||||
name: 'getSortedSetRank' + sort,
|
||||
text: `
|
||||
SELECT (SELECT r
|
||||
@@ -306,55 +266,51 @@ SELECT (SELECT r
|
||||
FROM UNNEST($1::TEXT[], $2::TEXT[]) WITH ORDINALITY kvi(k, v, i)
|
||||
ORDER BY kvi.i ASC`,
|
||||
values: [keys, values],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
callback(null, res.rows.map(function (r) { return r.r === null ? null : parseFloat(r.r); }));
|
||||
});
|
||||
|
||||
return res.rows.map(r => (r.r === null ? null : parseFloat(r.r)));
|
||||
}
|
||||
|
||||
module.sortedSetsRanks = function (keys, values, callback) {
|
||||
module.sortedSetsRanks = async function (keys, values) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
|
||||
getSortedSetRank('ASC', keys, values, callback);
|
||||
return await getSortedSetRank('ASC', keys, values);
|
||||
};
|
||||
|
||||
module.sortedSetsRevRanks = function (keys, values, callback) {
|
||||
module.sortedSetsRevRanks = async function (keys, values) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
|
||||
getSortedSetRank('DESC', keys, values, callback);
|
||||
return await getSortedSetRank('DESC', keys, values);
|
||||
};
|
||||
|
||||
module.sortedSetRanks = function (key, values, callback) {
|
||||
module.sortedSetRanks = async function (key, values) {
|
||||
if (!Array.isArray(values) || !values.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
|
||||
getSortedSetRank('ASC', new Array(values.length).fill(key), values, callback);
|
||||
return await getSortedSetRank('ASC', new Array(values.length).fill(key), values);
|
||||
};
|
||||
|
||||
module.sortedSetRevRanks = function (key, values, callback) {
|
||||
module.sortedSetRevRanks = async function (key, values) {
|
||||
if (!Array.isArray(values) || !values.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
|
||||
getSortedSetRank('DESC', new Array(values.length).fill(key), values, callback);
|
||||
return await getSortedSetRank('DESC', new Array(values.length).fill(key), values);
|
||||
};
|
||||
|
||||
module.sortedSetScore = function (key, value, callback) {
|
||||
module.sortedSetScore = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback(null, null);
|
||||
return null;
|
||||
}
|
||||
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
query({
|
||||
const res = await query({
|
||||
name: 'sortedSetScore',
|
||||
text: `
|
||||
SELECT z."score" s
|
||||
@@ -365,27 +321,21 @@ SELECT z."score" s
|
||||
WHERE o."_key" = $1::TEXT
|
||||
AND z."value" = $2::TEXT`,
|
||||
values: [key, value],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (res.rows.length) {
|
||||
return callback(null, parseFloat(res.rows[0].s));
|
||||
}
|
||||
|
||||
callback(null, null);
|
||||
});
|
||||
if (res.rows.length) {
|
||||
return parseFloat(res.rows[0].s);
|
||||
}
|
||||
return null;
|
||||
};
|
||||
|
||||
module.sortedSetsScore = function (keys, value, callback) {
|
||||
module.sortedSetsScore = async function (keys, value) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
query({
|
||||
const res = await query({
|
||||
name: 'sortedSetsScore',
|
||||
text: `
|
||||
SELECT o."_key" k,
|
||||
@@ -397,31 +347,24 @@ SELECT o."_key" k,
|
||||
WHERE o."_key" = ANY($1::TEXT[])
|
||||
AND z."value" = $2::TEXT`,
|
||||
values: [keys, value],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
});
|
||||
|
||||
callback(null, keys.map(function (k) {
|
||||
var s = res.rows.find(function (r) {
|
||||
return r.k === k;
|
||||
});
|
||||
|
||||
return s ? parseFloat(s.s) : null;
|
||||
}));
|
||||
return keys.map(function (k) {
|
||||
var s = res.rows.find(r => r.k === k);
|
||||
return s ? parseFloat(s.s) : null;
|
||||
});
|
||||
};
|
||||
|
||||
module.sortedSetScores = function (key, values, callback) {
|
||||
module.sortedSetScores = async function (key, values) {
|
||||
if (!key) {
|
||||
return setImmediate(callback, null, null);
|
||||
return null;
|
||||
}
|
||||
if (!values.length) {
|
||||
return setImmediate(callback, null, []);
|
||||
return [];
|
||||
}
|
||||
values = values.map(helpers.valueToString);
|
||||
|
||||
query({
|
||||
const res = await query({
|
||||
name: 'sortedSetScores',
|
||||
text: `
|
||||
SELECT z."value" v,
|
||||
@@ -433,29 +376,22 @@ SELECT z."value" v,
|
||||
WHERE o."_key" = $1::TEXT
|
||||
AND z."value" = ANY($2::TEXT[])`,
|
||||
values: [key, values],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
});
|
||||
|
||||
callback(null, values.map(function (v) {
|
||||
var s = res.rows.find(function (r) {
|
||||
return r.v === v;
|
||||
});
|
||||
|
||||
return s ? parseFloat(s.s) : null;
|
||||
}));
|
||||
return values.map(function (v) {
|
||||
var s = res.rows.find(r => r.v === v);
|
||||
return s ? parseFloat(s.s) : null;
|
||||
});
|
||||
};
|
||||
|
||||
module.isSortedSetMember = function (key, value, callback) {
|
||||
module.isSortedSetMember = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
query({
|
||||
const res = await query({
|
||||
name: 'isSortedSetMember',
|
||||
text: `
|
||||
SELECT 1
|
||||
@@ -466,23 +402,19 @@ SELECT 1
|
||||
WHERE o."_key" = $1::TEXT
|
||||
AND z."value" = $2::TEXT`,
|
||||
values: [key, value],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
callback(null, !!res.rows.length);
|
||||
});
|
||||
|
||||
return !!res.rows.length;
|
||||
};
|
||||
|
||||
module.isSortedSetMembers = function (key, values, callback) {
|
||||
module.isSortedSetMembers = async function (key, values) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
values = values.map(helpers.valueToString);
|
||||
|
||||
query({
|
||||
const res = await query({
|
||||
name: 'isSortedSetMembers',
|
||||
text: `
|
||||
SELECT z."value" v
|
||||
@@ -493,27 +425,21 @@ SELECT z."value" v
|
||||
WHERE o."_key" = $1::TEXT
|
||||
AND z."value" = ANY($2::TEXT[])`,
|
||||
values: [key, values],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
});
|
||||
|
||||
callback(null, values.map(function (v) {
|
||||
return res.rows.some(function (r) {
|
||||
return r.v === v;
|
||||
});
|
||||
}));
|
||||
return values.map(function (v) {
|
||||
return res.rows.some(r => r.v === v);
|
||||
});
|
||||
};
|
||||
|
||||
module.isMemberOfSortedSets = function (keys, value, callback) {
|
||||
module.isMemberOfSortedSets = async function (keys, value) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return setImmediate(callback, null, []);
|
||||
return [];
|
||||
}
|
||||
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
query({
|
||||
const res = await query({
|
||||
name: 'isMemberOfSortedSets',
|
||||
text: `
|
||||
SELECT o."_key" k
|
||||
@@ -524,25 +450,19 @@ SELECT o."_key" k
|
||||
WHERE o."_key" = ANY($1::TEXT[])
|
||||
AND z."value" = $2::TEXT`,
|
||||
values: [keys, value],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
});
|
||||
|
||||
callback(null, keys.map(function (k) {
|
||||
return res.rows.some(function (r) {
|
||||
return r.k === k;
|
||||
});
|
||||
}));
|
||||
return keys.map(function (k) {
|
||||
return res.rows.some(r => r.k === k);
|
||||
});
|
||||
};
|
||||
|
||||
module.getSortedSetsMembers = function (keys, callback) {
|
||||
module.getSortedSetsMembers = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
|
||||
query({
|
||||
const res = await query({
|
||||
name: 'getSortedSetsMembers',
|
||||
text: `
|
||||
SELECT o."_key" k,
|
||||
@@ -554,61 +474,50 @@ SELECT o."_key" k,
|
||||
WHERE o."_key" = ANY($1::TEXT[])
|
||||
GROUP BY o."_key"`,
|
||||
values: [keys],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
});
|
||||
|
||||
callback(null, keys.map(function (k) {
|
||||
return (res.rows.find(function (r) {
|
||||
return r.k === k;
|
||||
}) || { m: [] }).m;
|
||||
}));
|
||||
return keys.map(function (k) {
|
||||
return (res.rows.find(r => r.k === k) || { m: [] }).m;
|
||||
});
|
||||
};
|
||||
|
||||
module.sortedSetIncrBy = function (key, increment, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.sortedSetIncrBy = async function (key, increment, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
value = helpers.valueToString(value);
|
||||
increment = parseFloat(increment);
|
||||
|
||||
module.transaction(function (tx, done) {
|
||||
async.waterfall([
|
||||
async.apply(helpers.ensureLegacyObjectType, tx.client, key, 'zset'),
|
||||
async.apply(tx.client.query.bind(tx.client), {
|
||||
name: 'sortedSetIncrBy',
|
||||
text: `
|
||||
return await module.transaction(async function (client) {
|
||||
var query = client.query.bind(client);
|
||||
await helpers.ensureLegacyObjectType(client, key, 'zset');
|
||||
const res = await query({
|
||||
name: 'sortedSetIncrBy',
|
||||
text: `
|
||||
INSERT INTO "legacy_zset" ("_key", "value", "score")
|
||||
VALUES ($1::TEXT, $2::TEXT, $3::NUMERIC)
|
||||
ON CONFLICT ("_key", "value")
|
||||
DO UPDATE SET "score" = "legacy_zset"."score" + $3::NUMERIC
|
||||
ON CONFLICT ("_key", "value")
|
||||
DO UPDATE SET "score" = "legacy_zset"."score" + $3::NUMERIC
|
||||
RETURNING "score" s`,
|
||||
values: [key, value, increment],
|
||||
}),
|
||||
function (res, next) {
|
||||
next(null, parseFloat(res.rows[0].s));
|
||||
},
|
||||
], done);
|
||||
}, callback);
|
||||
values: [key, value, increment],
|
||||
});
|
||||
return parseFloat(res.rows[0].s);
|
||||
});
|
||||
};
|
||||
|
||||
module.getSortedSetRangeByLex = function (key, min, max, start, count, callback) {
|
||||
sortedSetLex(key, min, max, 1, start, count, callback);
|
||||
module.getSortedSetRangeByLex = async function (key, min, max, start, count) {
|
||||
return await sortedSetLex(key, min, max, 1, start, count);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRangeByLex = function (key, max, min, start, count, callback) {
|
||||
sortedSetLex(key, min, max, -1, start, count, callback);
|
||||
module.getSortedSetRevRangeByLex = async function (key, max, min, start, count) {
|
||||
return await sortedSetLex(key, min, max, -1, start, count);
|
||||
};
|
||||
|
||||
module.sortedSetLexCount = function (key, min, max, callback) {
|
||||
module.sortedSetLexCount = async function (key, min, max) {
|
||||
var q = buildLexQuery(key, min, max);
|
||||
|
||||
query({
|
||||
const res = await query({
|
||||
name: 'sortedSetLexCount' + q.suffix,
|
||||
text: `
|
||||
SELECT COUNT(*) c
|
||||
@@ -618,26 +527,19 @@ SELECT COUNT(*) c
|
||||
AND o."type" = z."type"
|
||||
WHERE ` + q.where,
|
||||
values: q.values,
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
callback(null, parseInt(res.rows[0].c, 10));
|
||||
});
|
||||
|
||||
return parseInt(res.rows[0].c, 10);
|
||||
};
|
||||
|
||||
function sortedSetLex(key, min, max, sort, start, count, callback) {
|
||||
if (!callback) {
|
||||
callback = start;
|
||||
start = 0;
|
||||
count = 0;
|
||||
}
|
||||
async function sortedSetLex(key, min, max, sort, start, count) {
|
||||
start = start !== undefined ? start : 0;
|
||||
count = count !== undefined ? count : 0;
|
||||
|
||||
var q = buildLexQuery(key, min, max);
|
||||
q.values.push(start);
|
||||
q.values.push(count <= 0 ? null : count);
|
||||
query({
|
||||
const res = await query({
|
||||
name: 'sortedSetLex' + (sort > 0 ? 'Asc' : 'Desc') + q.suffix,
|
||||
text: `
|
||||
SELECT z."value" v
|
||||
@@ -650,22 +552,14 @@ SELECT z."value" v
|
||||
LIMIT $` + q.values.length + `::INTEGER
|
||||
OFFSET $` + (q.values.length - 1) + `::INTEGER`,
|
||||
values: q.values,
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
callback(null, res.rows.map(function (r) {
|
||||
return r.v;
|
||||
}));
|
||||
});
|
||||
|
||||
return res.rows.map(r => r.v);
|
||||
}
|
||||
|
||||
module.sortedSetRemoveRangeByLex = function (key, min, max, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.sortedSetRemoveRangeByLex = async function (key, min, max) {
|
||||
var q = buildLexQuery(key, min, max);
|
||||
query({
|
||||
await query({
|
||||
name: 'sortedSetRemoveRangeByLex' + q.suffix,
|
||||
text: `
|
||||
DELETE FROM "legacy_zset" z
|
||||
@@ -674,8 +568,6 @@ DELETE FROM "legacy_zset" z
|
||||
AND o."type" = z."type"
|
||||
AND ` + q.where,
|
||||
values: q.values,
|
||||
}, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
};
|
||||
|
||||
@@ -721,16 +613,10 @@ DELETE FROM "legacy_zset" z
|
||||
return q;
|
||||
}
|
||||
|
||||
module.processSortedSet = function (setKey, process, options, callback) {
|
||||
var Cursor = require('pg-cursor');
|
||||
|
||||
db.connect(function (err, client, done) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
var batchSize = (options || {}).batch || 100;
|
||||
var query = client.query(new Cursor(`
|
||||
module.processSortedSet = async function (setKey, process, options) {
|
||||
const client = await db.connect();
|
||||
var batchSize = (options || {}).batch || 100;
|
||||
var cursor = client.query(new Cursor(`
|
||||
SELECT z."value", z."score"
|
||||
FROM "legacy_object_live" o
|
||||
INNER JOIN "legacy_zset" z
|
||||
@@ -739,43 +625,32 @@ SELECT z."value", z."score"
|
||||
WHERE o."_key" = $1::TEXT
|
||||
ORDER BY z."score" ASC, z."value" ASC`, [setKey]));
|
||||
|
||||
var isDone = false;
|
||||
if (process && process.constructor && process.constructor.name !== 'AsyncFunction') {
|
||||
process = util.promisify(process);
|
||||
}
|
||||
|
||||
async.whilst(function (next) {
|
||||
next(null, !isDone);
|
||||
}, function (next) {
|
||||
query.read(batchSize, function (err, rows) {
|
||||
if (err) {
|
||||
return next(err);
|
||||
}
|
||||
while (true) {
|
||||
/* eslint-disable no-await-in-loop */
|
||||
let rows = await cursor.readAsync(batchSize);
|
||||
if (!rows.length) {
|
||||
client.release();
|
||||
return;
|
||||
}
|
||||
|
||||
if (!rows.length) {
|
||||
isDone = true;
|
||||
return next();
|
||||
}
|
||||
|
||||
rows = rows.map(function (row) {
|
||||
return options.withScores ? row : row.value;
|
||||
});
|
||||
|
||||
process(rows, function (err) {
|
||||
if (err) {
|
||||
return query.close(function () {
|
||||
next(err);
|
||||
});
|
||||
}
|
||||
|
||||
if (options.interval) {
|
||||
setTimeout(next, options.interval);
|
||||
} else {
|
||||
next();
|
||||
}
|
||||
});
|
||||
});
|
||||
}, function (err) {
|
||||
done();
|
||||
callback(err);
|
||||
});
|
||||
});
|
||||
if (options.withScores) {
|
||||
rows = rows.map(r => ({ value: r.value, score: parseFloat(r.score) }));
|
||||
} else {
|
||||
rows = rows.map(r => r.value);
|
||||
}
|
||||
try {
|
||||
await process(rows);
|
||||
} catch (err) {
|
||||
await query.close();
|
||||
throw err;
|
||||
}
|
||||
if (options.interval) {
|
||||
await sleep(options.interval);
|
||||
}
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,134 +1,112 @@
|
||||
'use strict';
|
||||
|
||||
var async = require('async');
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.postgres;
|
||||
var helpers = require('../helpers');
|
||||
var utils = require('../../../utils');
|
||||
|
||||
module.sortedSetAdd = function (key, score, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.sortedSetAdd = async function (key, score, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
if (Array.isArray(score) && Array.isArray(value)) {
|
||||
return sortedSetAddBulk(key, score, value, callback);
|
||||
return await sortedSetAddBulk(key, score, value);
|
||||
}
|
||||
if (!utils.isNumber(score)) {
|
||||
return setImmediate(callback, new Error('[[error:invalid-score, ' + score + ']]'));
|
||||
throw new Error('[[error:invalid-score, ' + score + ']]');
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
score = parseFloat(score);
|
||||
|
||||
module.transaction(function (tx, done) {
|
||||
var query = tx.client.query.bind(tx.client);
|
||||
await module.transaction(async function (client) {
|
||||
var query = client.query.bind(client);
|
||||
|
||||
async.series([
|
||||
async.apply(helpers.ensureLegacyObjectType, tx.client, key, 'zset'),
|
||||
async.apply(query, {
|
||||
name: 'sortedSetAdd',
|
||||
text: `
|
||||
INSERT INTO "legacy_zset" ("_key", "value", "score")
|
||||
VALUES ($1::TEXT, $2::TEXT, $3::NUMERIC)
|
||||
ON CONFLICT ("_key", "value")
|
||||
DO UPDATE SET "score" = $3::NUMERIC`,
|
||||
values: [key, value, score],
|
||||
}),
|
||||
], function (err) {
|
||||
done(err);
|
||||
await helpers.ensureLegacyObjectType(client, key, 'zset');
|
||||
await query({
|
||||
name: 'sortedSetAdd',
|
||||
text: `
|
||||
INSERT INTO "legacy_zset" ("_key", "value", "score")
|
||||
VALUES ($1::TEXT, $2::TEXT, $3::NUMERIC)
|
||||
ON CONFLICT ("_key", "value")
|
||||
DO UPDATE SET "score" = $3::NUMERIC`,
|
||||
values: [key, value, score],
|
||||
});
|
||||
}, callback);
|
||||
});
|
||||
};
|
||||
|
||||
function sortedSetAddBulk(key, scores, values, callback) {
|
||||
async function sortedSetAddBulk(key, scores, values) {
|
||||
if (!scores.length || !values.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
if (scores.length !== values.length) {
|
||||
return callback(new Error('[[error:invalid-data]]'));
|
||||
throw new Error('[[error:invalid-data]]');
|
||||
}
|
||||
for (let i = 0; i < scores.length; i += 1) {
|
||||
if (!utils.isNumber(scores[i])) {
|
||||
return setImmediate(callback, new Error('[[error:invalid-score, ' + scores[i] + ']]'));
|
||||
throw new Error('[[error:invalid-score, ' + scores[i] + ']]');
|
||||
}
|
||||
}
|
||||
values = values.map(helpers.valueToString);
|
||||
scores = scores.map(function (score) {
|
||||
return parseFloat(score);
|
||||
});
|
||||
scores = scores.map(score => parseFloat(score));
|
||||
|
||||
helpers.removeDuplicateValues(values, scores);
|
||||
|
||||
module.transaction(function (tx, done) {
|
||||
var query = tx.client.query.bind(tx.client);
|
||||
|
||||
async.series([
|
||||
async.apply(helpers.ensureLegacyObjectType, tx.client, key, 'zset'),
|
||||
async.apply(query, {
|
||||
name: 'sortedSetAddBulk',
|
||||
text: `
|
||||
await module.transaction(async function (client) {
|
||||
var query = client.query.bind(client);
|
||||
await helpers.ensureLegacyObjectType(client, key, 'zset');
|
||||
await query({
|
||||
name: 'sortedSetAddBulk',
|
||||
text: `
|
||||
INSERT INTO "legacy_zset" ("_key", "value", "score")
|
||||
SELECT $1::TEXT, v, s
|
||||
FROM UNNEST($2::TEXT[], $3::NUMERIC[]) vs(v, s)
|
||||
ON CONFLICT ("_key", "value")
|
||||
DO UPDATE SET "score" = EXCLUDED."score"`,
|
||||
values: [key, values, scores],
|
||||
}),
|
||||
], function (err) {
|
||||
done(err);
|
||||
FROM UNNEST($2::TEXT[], $3::NUMERIC[]) vs(v, s)
|
||||
ON CONFLICT ("_key", "value")
|
||||
DO UPDATE SET "score" = EXCLUDED."score"`,
|
||||
values: [key, values, scores],
|
||||
});
|
||||
}, callback);
|
||||
});
|
||||
}
|
||||
|
||||
module.sortedSetsAdd = function (keys, scores, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.sortedSetsAdd = async function (keys, scores, value) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
const isArrayOfScores = Array.isArray(scores);
|
||||
if (!isArrayOfScores && !utils.isNumber(scores)) {
|
||||
return setImmediate(callback, new Error('[[error:invalid-score, ' + scores + ']]'));
|
||||
throw new Error('[[error:invalid-score, ' + scores + ']]');
|
||||
}
|
||||
|
||||
if (isArrayOfScores && scores.length !== keys.length) {
|
||||
return setImmediate(callback, new Error('[[error:invalid-data]]'));
|
||||
throw new Error('[[error:invalid-data]]');
|
||||
}
|
||||
|
||||
value = helpers.valueToString(value);
|
||||
scores = isArrayOfScores ? scores.map(score => parseFloat(score)) : parseFloat(scores);
|
||||
|
||||
module.transaction(function (tx, done) {
|
||||
var query = tx.client.query.bind(tx.client);
|
||||
|
||||
async.series([
|
||||
async.apply(helpers.ensureLegacyObjectsType, tx.client, keys, 'zset'),
|
||||
async.apply(query, {
|
||||
name: isArrayOfScores ? 'sortedSetsAddScores' : 'sortedSetsAdd',
|
||||
text: isArrayOfScores ? `
|
||||
await module.transaction(async function (client) {
|
||||
var query = client.query.bind(client);
|
||||
await helpers.ensureLegacyObjectsType(client, keys, 'zset');
|
||||
await query({
|
||||
name: isArrayOfScores ? 'sortedSetsAddScores' : 'sortedSetsAdd',
|
||||
text: isArrayOfScores ? `
|
||||
INSERT INTO "legacy_zset" ("_key", "value", "score")
|
||||
SELECT k, $2::TEXT, s
|
||||
FROM UNNEST($1::TEXT[], $3::NUMERIC[]) vs(k, s)
|
||||
ON CONFLICT ("_key", "value")
|
||||
DO UPDATE SET "score" = EXCLUDED."score"` : `
|
||||
FROM UNNEST($1::TEXT[], $3::NUMERIC[]) vs(k, s)
|
||||
ON CONFLICT ("_key", "value")
|
||||
DO UPDATE SET "score" = EXCLUDED."score"` : `
|
||||
INSERT INTO "legacy_zset" ("_key", "value", "score")
|
||||
SELECT k, $2::TEXT, $3::NUMERIC
|
||||
FROM UNNEST($1::TEXT[]) k
|
||||
ON CONFLICT ("_key", "value")
|
||||
DO UPDATE SET "score" = $3::NUMERIC`,
|
||||
values: [keys, value, scores],
|
||||
}),
|
||||
], function (err) {
|
||||
done(err);
|
||||
SELECT k, $2::TEXT, $3::NUMERIC
|
||||
FROM UNNEST($1::TEXT[]) k
|
||||
ON CONFLICT ("_key", "value")
|
||||
DO UPDATE SET "score" = $3::NUMERIC`,
|
||||
values: [keys, value, scores],
|
||||
});
|
||||
}, callback);
|
||||
});
|
||||
};
|
||||
|
||||
module.sortedSetAddBulk = function (data, callback) {
|
||||
module.sortedSetAddBulk = async function (data) {
|
||||
if (!Array.isArray(data) || !data.length) {
|
||||
return setImmediate(callback);
|
||||
return;
|
||||
}
|
||||
const keys = [];
|
||||
const values = [];
|
||||
@@ -138,24 +116,19 @@ INSERT INTO "legacy_zset" ("_key", "value", "score")
|
||||
scores.push(item[1]);
|
||||
values.push(item[2]);
|
||||
});
|
||||
module.transaction(function (tx, done) {
|
||||
var query = tx.client.query.bind(tx.client);
|
||||
|
||||
async.series([
|
||||
async.apply(helpers.ensureLegacyObjectsType, tx.client, keys, 'zset'),
|
||||
async.apply(query, {
|
||||
name: 'sortedSetAddBulk2',
|
||||
text: `
|
||||
await module.transaction(async function (client) {
|
||||
var query = client.query.bind(client);
|
||||
await helpers.ensureLegacyObjectsType(client, keys, 'zset');
|
||||
await query({
|
||||
name: 'sortedSetAddBulk2',
|
||||
text: `
|
||||
INSERT INTO "legacy_zset" ("_key", "value", "score")
|
||||
SELECT k, v, s
|
||||
FROM UNNEST($1::TEXT[], $2::TEXT[], $3::NUMERIC[]) vs(k, v, s)
|
||||
ON CONFLICT ("_key", "value")
|
||||
DO UPDATE SET "score" = EXCLUDED."score"`,
|
||||
values: [keys, values, scores],
|
||||
}),
|
||||
], function (err) {
|
||||
done(err);
|
||||
FROM UNNEST($1::TEXT[], $2::TEXT[], $3::NUMERIC[]) vs(k, v, s)
|
||||
ON CONFLICT ("_key", "value")
|
||||
DO UPDATE SET "score" = EXCLUDED."score"`,
|
||||
values: [keys, values, scores],
|
||||
});
|
||||
}, callback);
|
||||
});
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (db, module) {
|
||||
module.sortedSetIntersectCard = function (keys, callback) {
|
||||
module.sortedSetIntersectCard = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
db.query({
|
||||
const res = await db.query({
|
||||
name: 'sortedSetIntersectCard',
|
||||
text: `
|
||||
WITH A AS (SELECT z."value" v,
|
||||
@@ -21,27 +21,22 @@ SELECT COUNT(*) c
|
||||
FROM A
|
||||
WHERE A.c = array_length($1::TEXT[], 1)`,
|
||||
values: [keys],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
callback(null, parseInt(res.rows[0].c, 10));
|
||||
});
|
||||
|
||||
return parseInt(res.rows[0].c, 10);
|
||||
};
|
||||
|
||||
|
||||
module.getSortedSetIntersect = function (params, callback) {
|
||||
module.getSortedSetIntersect = async function (params) {
|
||||
params.sort = 1;
|
||||
getSortedSetIntersect(params, callback);
|
||||
return await getSortedSetIntersect(params);
|
||||
};
|
||||
|
||||
module.getSortedSetRevIntersect = function (params, callback) {
|
||||
module.getSortedSetRevIntersect = async function (params) {
|
||||
params.sort = -1;
|
||||
getSortedSetIntersect(params, callback);
|
||||
return await getSortedSetIntersect(params);
|
||||
};
|
||||
|
||||
function getSortedSetIntersect(params, callback) {
|
||||
async function getSortedSetIntersect(params) {
|
||||
var sets = params.sets;
|
||||
var start = params.hasOwnProperty('start') ? params.start : 0;
|
||||
var stop = params.hasOwnProperty('stop') ? params.stop : -1;
|
||||
@@ -60,7 +55,7 @@ SELECT COUNT(*) c
|
||||
limit = null;
|
||||
}
|
||||
|
||||
db.query({
|
||||
const res = await db.query({
|
||||
name: 'getSortedSetIntersect' + aggregate + (params.sort > 0 ? 'Asc' : 'Desc') + 'WithScores',
|
||||
text: `
|
||||
WITH A AS (SELECT z."value",
|
||||
@@ -81,25 +76,19 @@ SELECT A."value",
|
||||
LIMIT $4::INTEGER
|
||||
OFFSET $3::INTEGER`,
|
||||
values: [sets, weights, start, limit],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (params.withScores) {
|
||||
res.rows = res.rows.map(function (r) {
|
||||
return {
|
||||
value: r.value,
|
||||
score: parseFloat(r.score),
|
||||
};
|
||||
});
|
||||
} else {
|
||||
res.rows = res.rows.map(function (r) {
|
||||
return r.value;
|
||||
});
|
||||
}
|
||||
|
||||
callback(null, res.rows);
|
||||
});
|
||||
|
||||
if (params.withScores) {
|
||||
res.rows = res.rows.map(function (r) {
|
||||
return {
|
||||
value: r.value,
|
||||
score: parseFloat(r.score),
|
||||
};
|
||||
});
|
||||
} else {
|
||||
res.rows = res.rows.map(r => r.value);
|
||||
}
|
||||
|
||||
return res.rows;
|
||||
}
|
||||
};
|
||||
|
||||
@@ -1,64 +1,55 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.postgres;
|
||||
|
||||
module.sortedSetRemove = function (key, value, callback) {
|
||||
function done(err) {
|
||||
if (callback) {
|
||||
callback(err);
|
||||
}
|
||||
}
|
||||
var helpers = require('../helpers');
|
||||
|
||||
module.sortedSetRemove = async function (key, value) {
|
||||
if (!key) {
|
||||
return done();
|
||||
return;
|
||||
}
|
||||
const isValueArray = Array.isArray(value);
|
||||
if (!value || (isValueArray && !value.length)) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!Array.isArray(key)) {
|
||||
key = [key];
|
||||
}
|
||||
|
||||
if (!Array.isArray(value)) {
|
||||
if (!isValueArray) {
|
||||
value = [value];
|
||||
}
|
||||
value = value.map(helpers.valueToString);
|
||||
|
||||
db.query({
|
||||
await db.query({
|
||||
name: 'sortedSetRemove',
|
||||
text: `
|
||||
DELETE FROM "legacy_zset"
|
||||
WHERE "_key" = ANY($1::TEXT[])
|
||||
AND "value" = ANY($2::TEXT[])`,
|
||||
values: [key, value],
|
||||
}, done);
|
||||
});
|
||||
};
|
||||
|
||||
module.sortedSetsRemove = function (keys, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.sortedSetsRemove = async function (keys, value) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
db.query({
|
||||
await db.query({
|
||||
name: 'sortedSetsRemove',
|
||||
text: `
|
||||
DELETE FROM "legacy_zset"
|
||||
WHERE "_key" = ANY($1::TEXT[])
|
||||
AND "value" = $2::TEXT`,
|
||||
values: [keys, value],
|
||||
}, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
};
|
||||
|
||||
module.sortedSetsRemoveRangeByScore = function (keys, min, max, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.sortedSetsRemoveRangeByScore = async function (keys, min, max) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
if (min === '-inf') {
|
||||
@@ -68,7 +59,7 @@ DELETE FROM "legacy_zset"
|
||||
max = null;
|
||||
}
|
||||
|
||||
db.query({
|
||||
await db.query({
|
||||
name: 'sortedSetsRemoveRangeByScore',
|
||||
text: `
|
||||
DELETE FROM "legacy_zset"
|
||||
@@ -76,8 +67,6 @@ DELETE FROM "legacy_zset"
|
||||
AND ("score" >= $2::NUMERIC OR $2::NUMERIC IS NULL)
|
||||
AND ("score" <= $3::NUMERIC OR $3::NUMERIC IS NULL)`,
|
||||
values: [keys, min, max],
|
||||
}, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (db, module) {
|
||||
module.sortedSetUnionCard = function (keys, callback) {
|
||||
module.sortedSetUnionCard = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
db.query({
|
||||
const res = await db.query({
|
||||
name: 'sortedSetUnionCard',
|
||||
text: `
|
||||
SELECT COUNT(DISTINCT z."value") c
|
||||
@@ -16,26 +16,21 @@ SELECT COUNT(DISTINCT z."value") c
|
||||
AND o."type" = z."type"
|
||||
WHERE o."_key" = ANY($1::TEXT[])`,
|
||||
values: [keys],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
callback(null, parseInt(res.rows[0].c, 10));
|
||||
});
|
||||
return res.rows[0].c;
|
||||
};
|
||||
|
||||
module.getSortedSetUnion = function (params, callback) {
|
||||
module.getSortedSetUnion = async function (params) {
|
||||
params.sort = 1;
|
||||
getSortedSetUnion(params, callback);
|
||||
return await getSortedSetUnion(params);
|
||||
};
|
||||
|
||||
module.getSortedSetRevUnion = function (params, callback) {
|
||||
module.getSortedSetRevUnion = async function (params) {
|
||||
params.sort = -1;
|
||||
getSortedSetUnion(params, callback);
|
||||
return await getSortedSetUnion(params);
|
||||
};
|
||||
|
||||
function getSortedSetUnion(params, callback) {
|
||||
async function getSortedSetUnion(params) {
|
||||
var sets = params.sets;
|
||||
var start = params.hasOwnProperty('start') ? params.start : 0;
|
||||
var stop = params.hasOwnProperty('stop') ? params.stop : -1;
|
||||
@@ -54,7 +49,7 @@ SELECT COUNT(DISTINCT z."value") c
|
||||
limit = null;
|
||||
}
|
||||
|
||||
db.query({
|
||||
const res = await db.query({
|
||||
name: 'getSortedSetUnion' + aggregate + (params.sort > 0 ? 'Asc' : 'Desc') + 'WithScores',
|
||||
text: `
|
||||
WITH A AS (SELECT z."value",
|
||||
@@ -73,25 +68,18 @@ SELECT A."value",
|
||||
LIMIT $4::INTEGER
|
||||
OFFSET $3::INTEGER`,
|
||||
values: [sets, weights, start, limit],
|
||||
}, function (err, res) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (params.withScores) {
|
||||
res.rows = res.rows.map(function (r) {
|
||||
return {
|
||||
value: r.value,
|
||||
score: parseFloat(r.score),
|
||||
};
|
||||
});
|
||||
} else {
|
||||
res.rows = res.rows.map(function (r) {
|
||||
return r.value;
|
||||
});
|
||||
}
|
||||
|
||||
callback(null, res.rows);
|
||||
});
|
||||
|
||||
if (params.withScores) {
|
||||
res.rows = res.rows.map(function (r) {
|
||||
return {
|
||||
value: r.value,
|
||||
score: parseFloat(r.score),
|
||||
};
|
||||
});
|
||||
} else {
|
||||
res.rows = res.rows.map(r => r.value);
|
||||
}
|
||||
return res.rows;
|
||||
}
|
||||
};
|
||||
|
||||
@@ -1,50 +1,32 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (db, dbNamespace, module) {
|
||||
module.transaction = function (perform, callback) {
|
||||
if (dbNamespace.active && dbNamespace.get('db')) {
|
||||
var client = dbNamespace.get('db');
|
||||
return client.query(`SAVEPOINT nodebb_subtx`, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
perform(module, function (err) {
|
||||
var args = Array.prototype.slice.call(arguments, 1);
|
||||
|
||||
client.query(err ? `ROLLBACK TO SAVEPOINT nodebb_subtx` : `RELEASE SAVEPOINT nodebb_subtx`, function (err1) {
|
||||
callback.apply(this, [err || err1].concat(args));
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
db.connect(function (err, client, done) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
module.exports = function (db, module) {
|
||||
module.transaction = async function (perform, txClient) {
|
||||
let res;
|
||||
if (txClient) {
|
||||
await txClient.query(`SAVEPOINT nodebb_subtx`);
|
||||
try {
|
||||
res = await perform(txClient);
|
||||
} catch (err) {
|
||||
await txClient.query(`ROLLBACK TO SAVEPOINT nodebb_subtx`);
|
||||
throw err;
|
||||
}
|
||||
await txClient.query(`RELEASE SAVEPOINT nodebb_subtx`);
|
||||
return res;
|
||||
}
|
||||
// see https://node-postgres.com/features/transactions#a-pooled-client-with-async-await
|
||||
const client = await db.connect();
|
||||
|
||||
dbNamespace.run(function () {
|
||||
dbNamespace.set('db', client);
|
||||
|
||||
client.query(`BEGIN`, function (err) {
|
||||
if (err) {
|
||||
done();
|
||||
dbNamespace.set('db', null);
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
perform(module, function (err) {
|
||||
var args = Array.prototype.slice.call(arguments, 1);
|
||||
|
||||
client.query(err ? `ROLLBACK` : `COMMIT`, function (err1) {
|
||||
done();
|
||||
dbNamespace.set('db', null);
|
||||
callback.apply(this, [err || err1].concat(args));
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
try {
|
||||
await client.query('BEGIN');
|
||||
res = await perform(client);
|
||||
await client.query('COMMIT');
|
||||
} catch (err) {
|
||||
await client.query('ROLLBACK');
|
||||
throw err;
|
||||
} finally {
|
||||
client.release();
|
||||
}
|
||||
return res;
|
||||
};
|
||||
};
|
||||
|
||||
@@ -56,6 +56,8 @@ redisModule.init = function (callback) {
|
||||
}
|
||||
redisModule.client = redisClient;
|
||||
|
||||
require('./redis/promisify')(redisClient);
|
||||
|
||||
require('./redis/main')(redisClient, redisModule);
|
||||
require('./redis/hash')(redisClient, redisModule);
|
||||
require('./redis/sets')(redisClient, redisModule);
|
||||
@@ -63,8 +65,7 @@ redisModule.init = function (callback) {
|
||||
require('./redis/list')(redisClient, redisModule);
|
||||
require('./redis/transaction')(redisClient, redisModule);
|
||||
|
||||
redisModule.async = require('../promisify')(redisModule, ['client', 'sessionStore']);
|
||||
|
||||
redisModule.async = require('../promisify')(redisModule, ['client', 'sessionStore', 'connect']);
|
||||
callback();
|
||||
});
|
||||
};
|
||||
@@ -220,6 +221,3 @@ redisModule.socketAdapter = function () {
|
||||
subClient: sub,
|
||||
});
|
||||
};
|
||||
|
||||
redisModule.helpers = redisModule.helpers || {};
|
||||
redisModule.helpers.redis = require('./redis/helpers');
|
||||
|
||||
@@ -1,19 +1,17 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (redisClient, module) {
|
||||
var helpers = module.helpers.redis;
|
||||
var helpers = require('./helpers');
|
||||
|
||||
const async = require('async');
|
||||
const _ = require('lodash');
|
||||
|
||||
const cache = require('../cache').create('redis');
|
||||
|
||||
module.objectCache = cache;
|
||||
|
||||
module.setObject = function (key, data, callback) {
|
||||
callback = callback || function () {};
|
||||
module.setObject = async function (key, data) {
|
||||
if (!key || !data) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
if (data.hasOwnProperty('')) {
|
||||
@@ -27,176 +25,147 @@ module.exports = function (redisClient, module) {
|
||||
});
|
||||
|
||||
if (!Object.keys(data).length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
redisClient.hmset(key, data, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
cache.delObjectCache(key);
|
||||
callback();
|
||||
});
|
||||
await redisClient.async.hmset(key, data);
|
||||
cache.delObjectCache(key);
|
||||
};
|
||||
|
||||
module.setObjectField = function (key, field, value, callback) {
|
||||
callback = callback || function () {};
|
||||
module.setObjectField = async function (key, field, value) {
|
||||
if (!field) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
redisClient.hset(key, field, value, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
cache.delObjectCache(key);
|
||||
callback();
|
||||
});
|
||||
await redisClient.async.hset(key, field, value);
|
||||
cache.delObjectCache(key);
|
||||
};
|
||||
|
||||
module.getObject = function (key, callback) {
|
||||
module.getObject = async function (key) {
|
||||
if (!key) {
|
||||
return setImmediate(callback, null, null);
|
||||
return null;
|
||||
}
|
||||
|
||||
module.getObjectsFields([key], [], function (err, data) {
|
||||
callback(err, data && data.length ? data[0] : null);
|
||||
});
|
||||
const data = await module.getObjectsFields([key], []);
|
||||
return data && data.length ? data[0] : null;
|
||||
};
|
||||
|
||||
module.getObjects = function (keys, callback) {
|
||||
module.getObjectsFields(keys, [], callback);
|
||||
module.getObjects = async function (keys) {
|
||||
return await module.getObjectsFields(keys, []);
|
||||
};
|
||||
|
||||
module.getObjectField = function (key, field, callback) {
|
||||
module.getObjectField = async function (key, field) {
|
||||
if (!key) {
|
||||
return setImmediate(callback, null, null);
|
||||
return null;
|
||||
}
|
||||
const cachedData = {};
|
||||
cache.getUnCachedKeys([key], cachedData);
|
||||
if (cachedData[key]) {
|
||||
return setImmediate(callback, null, cachedData[key].hasOwnProperty(field) ? cachedData[key][field] : null);
|
||||
return cachedData[key].hasOwnProperty(field) ? cachedData[key][field] : null;
|
||||
}
|
||||
redisClient.hget(key, field, callback);
|
||||
return await redisClient.async.hget(key, field);
|
||||
};
|
||||
|
||||
module.getObjectFields = function (key, fields, callback) {
|
||||
module.getObjectFields = async function (key, fields) {
|
||||
if (!key) {
|
||||
return setImmediate(callback, null, null);
|
||||
return null;
|
||||
}
|
||||
module.getObjectsFields([key], fields, function (err, results) {
|
||||
callback(err, results ? results[0] : null);
|
||||
});
|
||||
const results = await module.getObjectsFields([key], fields);
|
||||
return results ? results[0] : null;
|
||||
};
|
||||
|
||||
module.getObjectsFields = function (keys, fields, callback) {
|
||||
module.getObjectsFields = async function (keys, fields) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return setImmediate(callback, null, []);
|
||||
return [];
|
||||
}
|
||||
if (!Array.isArray(fields)) {
|
||||
return callback(null, keys.map(function () { return {}; }));
|
||||
return keys.map(function () { return {}; });
|
||||
}
|
||||
const cachedData = {};
|
||||
const unCachedKeys = cache.getUnCachedKeys(keys, cachedData);
|
||||
|
||||
async.waterfall([
|
||||
function (next) {
|
||||
if (unCachedKeys.length > 1) {
|
||||
helpers.execKeys(redisClient, 'batch', 'hgetall', unCachedKeys, next);
|
||||
} else if (unCachedKeys.length === 1) {
|
||||
redisClient.hgetall(unCachedKeys[0], (err, data) => next(err, [data]));
|
||||
} else {
|
||||
next(null, []);
|
||||
}
|
||||
},
|
||||
function (data, next) {
|
||||
unCachedKeys.forEach(function (key, i) {
|
||||
cachedData[key] = data[i] || null;
|
||||
cache.set(key, cachedData[key]);
|
||||
});
|
||||
|
||||
var mapped = keys.map(function (key) {
|
||||
if (!fields.length) {
|
||||
return _.clone(cachedData[key]);
|
||||
}
|
||||
|
||||
const item = cachedData[key] || {};
|
||||
const result = {};
|
||||
fields.forEach((field) => {
|
||||
result[field] = item[field] !== undefined ? item[field] : null;
|
||||
});
|
||||
return result;
|
||||
});
|
||||
next(null, mapped);
|
||||
},
|
||||
], callback);
|
||||
};
|
||||
|
||||
module.getObjectKeys = function (key, callback) {
|
||||
redisClient.hkeys(key, callback);
|
||||
};
|
||||
|
||||
module.getObjectValues = function (key, callback) {
|
||||
redisClient.hvals(key, callback);
|
||||
};
|
||||
|
||||
module.isObjectField = function (key, field, callback) {
|
||||
redisClient.hexists(key, field, function (err, exists) {
|
||||
callback(err, exists === 1);
|
||||
});
|
||||
};
|
||||
|
||||
module.isObjectFields = function (key, fields, callback) {
|
||||
helpers.execKeyValues(redisClient, 'batch', 'hexists', key, fields, function (err, results) {
|
||||
callback(err, Array.isArray(results) ? helpers.resultsToBool(results) : null);
|
||||
});
|
||||
};
|
||||
|
||||
module.deleteObjectField = function (key, field, callback) {
|
||||
callback = callback || function () {};
|
||||
if (key === undefined || key === null || field === undefined || field === null) {
|
||||
return setImmediate(callback);
|
||||
let data = [];
|
||||
if (unCachedKeys.length > 1) {
|
||||
const batch = redisClient.batch();
|
||||
unCachedKeys.forEach(k => batch.hgetall(k));
|
||||
data = await helpers.execBatch(batch);
|
||||
} else if (unCachedKeys.length === 1) {
|
||||
data = [await redisClient.async.hgetall(unCachedKeys[0])];
|
||||
}
|
||||
redisClient.hdel(key, field, function (err) {
|
||||
cache.delObjectCache(key);
|
||||
callback(err);
|
||||
|
||||
unCachedKeys.forEach(function (key, i) {
|
||||
cachedData[key] = data[i] || null;
|
||||
cache.set(key, cachedData[key]);
|
||||
});
|
||||
};
|
||||
|
||||
module.deleteObjectFields = function (key, fields, callback) {
|
||||
helpers.execKeyValues(redisClient, 'batch', 'hdel', key, fields, function (err) {
|
||||
cache.delObjectCache(key);
|
||||
callback(err);
|
||||
});
|
||||
};
|
||||
|
||||
module.incrObjectField = function (key, field, callback) {
|
||||
module.incrObjectFieldBy(key, field, 1, callback);
|
||||
};
|
||||
|
||||
module.decrObjectField = function (key, field, callback) {
|
||||
module.incrObjectFieldBy(key, field, -1, callback);
|
||||
};
|
||||
|
||||
module.incrObjectFieldBy = function (key, field, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
function done(err, result) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
const mapped = keys.map(function (key) {
|
||||
if (!fields.length) {
|
||||
return _.clone(cachedData[key]);
|
||||
}
|
||||
cache.delObjectCache(key);
|
||||
callback(null, Array.isArray(result) ? result.map(value => parseInt(value, 10)) : parseInt(result, 10));
|
||||
|
||||
const item = cachedData[key] || {};
|
||||
const result = {};
|
||||
fields.forEach((field) => {
|
||||
result[field] = item[field] !== undefined ? item[field] : null;
|
||||
});
|
||||
return result;
|
||||
});
|
||||
return mapped;
|
||||
};
|
||||
|
||||
module.getObjectKeys = async function (key) {
|
||||
return await redisClient.async.hkeys(key);
|
||||
};
|
||||
|
||||
module.getObjectValues = async function (key) {
|
||||
return await redisClient.async.hvals(key);
|
||||
};
|
||||
|
||||
module.isObjectField = async function (key, field) {
|
||||
const exists = await redisClient.async.hexists(key, field);
|
||||
return exists === 1;
|
||||
};
|
||||
|
||||
module.isObjectFields = async function (key, fields) {
|
||||
const batch = redisClient.batch();
|
||||
fields.forEach(f => batch.hexists(String(key), String(f)));
|
||||
const results = await helpers.execBatch(batch);
|
||||
return Array.isArray(results) ? helpers.resultsToBool(results) : null;
|
||||
};
|
||||
|
||||
module.deleteObjectField = async function (key, field) {
|
||||
if (key === undefined || key === null || field === undefined || field === null) {
|
||||
return;
|
||||
}
|
||||
await redisClient.async.hdel(key, field);
|
||||
cache.delObjectCache(key);
|
||||
};
|
||||
|
||||
module.deleteObjectFields = async function (key, fields) {
|
||||
await redisClient.async.hdel(key, fields);
|
||||
cache.delObjectCache(key);
|
||||
};
|
||||
|
||||
module.incrObjectField = async function (key, field) {
|
||||
return await module.incrObjectFieldBy(key, field, 1);
|
||||
};
|
||||
|
||||
module.decrObjectField = async function (key, field) {
|
||||
return await module.incrObjectFieldBy(key, field, -1);
|
||||
};
|
||||
|
||||
module.incrObjectFieldBy = async function (key, field, value) {
|
||||
value = parseInt(value, 10);
|
||||
if (!key || isNaN(value)) {
|
||||
return callback(null, null);
|
||||
return null;
|
||||
}
|
||||
let result;
|
||||
if (Array.isArray(key)) {
|
||||
var batch = redisClient.batch();
|
||||
key.forEach(function (key) {
|
||||
batch.hincrby(key, field, value);
|
||||
});
|
||||
batch.exec(done);
|
||||
key.forEach(k => batch.hincrby(k, field, value));
|
||||
result = await helpers.execBatch(batch);
|
||||
} else {
|
||||
redisClient.hincrby(key, field, value, done);
|
||||
result = await redisClient.async.hincrby(key, field, value);
|
||||
}
|
||||
cache.delObjectCache(key);
|
||||
return Array.isArray(result) ? result.map(value => parseInt(value, 10)) : parseInt(result, 10);
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,9 +1,16 @@
|
||||
'use strict';
|
||||
|
||||
const util = require('util');
|
||||
|
||||
var helpers = module.exports;
|
||||
|
||||
helpers.noop = function () {};
|
||||
|
||||
helpers.execBatch = async function (batch) {
|
||||
const proFn = util.promisify(batch.exec).bind(batch);
|
||||
return await proFn();
|
||||
};
|
||||
|
||||
helpers.execKeys = function (redisClient, type, command, keys, callback) {
|
||||
callback = callback || function () {};
|
||||
var queue = redisClient[type]();
|
||||
|
||||
@@ -1,63 +1,49 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (redisClient, module) {
|
||||
module.listPrepend = function (key, value, callback) {
|
||||
callback = callback || function () {};
|
||||
module.listPrepend = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
redisClient.lpush(key, value, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await redisClient.async.lpush(key, value);
|
||||
};
|
||||
|
||||
module.listAppend = function (key, value, callback) {
|
||||
callback = callback || function () {};
|
||||
module.listAppend = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
redisClient.rpush(key, value, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await redisClient.async.rpush(key, value);
|
||||
};
|
||||
|
||||
module.listRemoveLast = function (key, callback) {
|
||||
callback = callback || function () {};
|
||||
module.listRemoveLast = async function (key) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
redisClient.rpop(key, callback);
|
||||
return await redisClient.async.rpop(key);
|
||||
};
|
||||
|
||||
module.listRemoveAll = function (key, value, callback) {
|
||||
callback = callback || function () {};
|
||||
module.listRemoveAll = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
redisClient.lrem(key, 0, value, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await redisClient.async.lrem(key, 0, value);
|
||||
};
|
||||
|
||||
module.listTrim = function (key, start, stop, callback) {
|
||||
callback = callback || function () {};
|
||||
module.listTrim = async function (key, start, stop) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
redisClient.ltrim(key, start, stop, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await redisClient.async.ltrim(key, start, stop);
|
||||
};
|
||||
|
||||
module.getListRange = function (key, start, stop, callback) {
|
||||
callback = callback || function () {};
|
||||
module.getListRange = async function (key, start, stop) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
redisClient.lrange(key, start, stop, callback);
|
||||
return await redisClient.async.lrange(key, start, stop);
|
||||
};
|
||||
|
||||
module.listLength = function (key, callback) {
|
||||
redisClient.llen(key, callback);
|
||||
module.listLength = async function (key) {
|
||||
return await redisClient.async.llen(key);
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,117 +1,83 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (redisClient, module) {
|
||||
var helpers = module.helpers.redis;
|
||||
var helpers = require('./helpers');
|
||||
|
||||
module.flushdb = function (callback) {
|
||||
redisClient.send_command('flushdb', [], function (err) {
|
||||
if (typeof callback === 'function') {
|
||||
callback(err);
|
||||
}
|
||||
});
|
||||
module.flushdb = async function () {
|
||||
await redisClient.async.send_command('flushdb', []);
|
||||
};
|
||||
|
||||
module.emptydb = function (callback) {
|
||||
module.flushdb(function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
module.objectCache.resetObjectCache();
|
||||
callback();
|
||||
});
|
||||
module.emptydb = async function () {
|
||||
await module.flushdb();
|
||||
module.objectCache.resetObjectCache();
|
||||
};
|
||||
|
||||
module.exists = function (key, callback) {
|
||||
module.exists = async function (key) {
|
||||
if (Array.isArray(key)) {
|
||||
helpers.execKeys(redisClient, 'batch', 'exists', key, function (err, data) {
|
||||
callback(err, data && data.map(exists => exists === 1));
|
||||
});
|
||||
} else {
|
||||
redisClient.exists(key, function (err, exists) {
|
||||
callback(err, exists === 1);
|
||||
});
|
||||
const batch = redisClient.batch();
|
||||
key.forEach(key => batch.exists(key));
|
||||
const data = await helpers.execBatch(batch);
|
||||
return data.map(exists => exists === 1);
|
||||
}
|
||||
const exists = await redisClient.async.exists(key);
|
||||
return exists === 1;
|
||||
};
|
||||
|
||||
module.delete = function (key, callback) {
|
||||
callback = callback || function () {};
|
||||
redisClient.del(key, function (err) {
|
||||
module.objectCache.delObjectCache(key);
|
||||
callback(err);
|
||||
});
|
||||
module.delete = async function (key) {
|
||||
await redisClient.async.del(key);
|
||||
module.objectCache.delObjectCache(key);
|
||||
};
|
||||
|
||||
module.deleteAll = function (keys, callback) {
|
||||
callback = callback || function () {};
|
||||
var batch = redisClient.batch();
|
||||
for (var i = 0; i < keys.length; i += 1) {
|
||||
batch.del(keys[i]);
|
||||
module.deleteAll = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return;
|
||||
}
|
||||
batch.exec(function (err) {
|
||||
module.objectCache.delObjectCache(keys);
|
||||
callback(err);
|
||||
});
|
||||
await redisClient.async.del(keys);
|
||||
module.objectCache.delObjectCache(keys);
|
||||
};
|
||||
|
||||
module.get = function (key, callback) {
|
||||
redisClient.get(key, callback);
|
||||
module.get = async function (key) {
|
||||
return await redisClient.async.get(key);
|
||||
};
|
||||
|
||||
module.set = function (key, value, callback) {
|
||||
callback = callback || function () {};
|
||||
redisClient.set(key, value, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
module.set = async function (key, value) {
|
||||
await redisClient.async.set(key, value);
|
||||
};
|
||||
|
||||
module.increment = function (key, callback) {
|
||||
callback = callback || function () {};
|
||||
redisClient.incr(key, callback);
|
||||
module.increment = async function (key) {
|
||||
return await redisClient.async.incr(key);
|
||||
};
|
||||
|
||||
module.rename = function (oldKey, newKey, callback) {
|
||||
callback = callback || function () {};
|
||||
redisClient.rename(oldKey, newKey, function (err) {
|
||||
module.rename = async function (oldKey, newKey) {
|
||||
try {
|
||||
await redisClient.async.rename(oldKey, newKey);
|
||||
} catch (err) {
|
||||
if (err && err.message !== 'ERR no such key') {
|
||||
return callback(err);
|
||||
throw err;
|
||||
}
|
||||
module.objectCache.delObjectCache(oldKey);
|
||||
module.objectCache.delObjectCache(newKey);
|
||||
callback();
|
||||
});
|
||||
}
|
||||
|
||||
module.objectCache.delObjectCache([oldKey, newKey]);
|
||||
};
|
||||
|
||||
module.type = function (key, callback) {
|
||||
redisClient.type(key, function (err, type) {
|
||||
callback(err, type !== 'none' ? type : null);
|
||||
});
|
||||
module.type = async function (key) {
|
||||
const type = await redisClient.async.type(key);
|
||||
return type !== 'none' ? type : null;
|
||||
};
|
||||
|
||||
module.expire = function (key, seconds, callback) {
|
||||
callback = callback || function () {};
|
||||
redisClient.expire(key, seconds, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
module.expire = async function (key, seconds) {
|
||||
await redisClient.async.expire(key, seconds);
|
||||
};
|
||||
|
||||
module.expireAt = function (key, timestamp, callback) {
|
||||
callback = callback || function () {};
|
||||
redisClient.expireat(key, timestamp, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
module.expireAt = async function (key, timestamp) {
|
||||
await redisClient.async.expireat(key, timestamp);
|
||||
};
|
||||
|
||||
module.pexpire = function (key, ms, callback) {
|
||||
callback = callback || function () {};
|
||||
redisClient.pexpire(key, ms, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
module.pexpire = async function (key, ms) {
|
||||
await redisClient.async.pexpire(key, ms);
|
||||
};
|
||||
|
||||
module.pexpireAt = function (key, timestamp, callback) {
|
||||
callback = callback || function () {};
|
||||
redisClient.pexpireat(key, timestamp, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
module.pexpireAt = async function (key, timestamp) {
|
||||
await redisClient.async.pexpireat(key, timestamp);
|
||||
};
|
||||
};
|
||||
|
||||
66
src/database/redis/promisify.js
Normal file
66
src/database/redis/promisify.js
Normal file
@@ -0,0 +1,66 @@
|
||||
'use strict';
|
||||
|
||||
const util = require('util');
|
||||
|
||||
module.exports = function (redisClient) {
|
||||
redisClient.async = {
|
||||
send_command: util.promisify(redisClient.send_command).bind(redisClient),
|
||||
|
||||
exists: util.promisify(redisClient.exists).bind(redisClient),
|
||||
|
||||
del: util.promisify(redisClient.del).bind(redisClient),
|
||||
get: util.promisify(redisClient.get).bind(redisClient),
|
||||
set: util.promisify(redisClient.set).bind(redisClient),
|
||||
incr: util.promisify(redisClient.incr).bind(redisClient),
|
||||
rename: util.promisify(redisClient.rename).bind(redisClient),
|
||||
type: util.promisify(redisClient.type).bind(redisClient),
|
||||
expire: util.promisify(redisClient.expire).bind(redisClient),
|
||||
expireat: util.promisify(redisClient.expireat).bind(redisClient),
|
||||
pexpire: util.promisify(redisClient.pexpire).bind(redisClient),
|
||||
pexpireat: util.promisify(redisClient.pexpireat).bind(redisClient),
|
||||
|
||||
hmset: util.promisify(redisClient.hmset).bind(redisClient),
|
||||
hset: util.promisify(redisClient.hset).bind(redisClient),
|
||||
hget: util.promisify(redisClient.hget).bind(redisClient),
|
||||
hdel: util.promisify(redisClient.hdel).bind(redisClient),
|
||||
hgetall: util.promisify(redisClient.hgetall).bind(redisClient),
|
||||
hkeys: util.promisify(redisClient.hkeys).bind(redisClient),
|
||||
hvals: util.promisify(redisClient.hvals).bind(redisClient),
|
||||
hexists: util.promisify(redisClient.hexists).bind(redisClient),
|
||||
hincrby: util.promisify(redisClient.hincrby).bind(redisClient),
|
||||
|
||||
sadd: util.promisify(redisClient.sadd).bind(redisClient),
|
||||
srem: util.promisify(redisClient.srem).bind(redisClient),
|
||||
sismember: util.promisify(redisClient.sismember).bind(redisClient),
|
||||
smembers: util.promisify(redisClient.smembers).bind(redisClient),
|
||||
scard: util.promisify(redisClient.scard).bind(redisClient),
|
||||
spop: util.promisify(redisClient.spop).bind(redisClient),
|
||||
|
||||
zadd: util.promisify(redisClient.zadd).bind(redisClient),
|
||||
zrem: util.promisify(redisClient.zrem).bind(redisClient),
|
||||
zrange: util.promisify(redisClient.zrange).bind(redisClient),
|
||||
zrevrange: util.promisify(redisClient.zrevrange).bind(redisClient),
|
||||
zrangebyscore: util.promisify(redisClient.zrangebyscore).bind(redisClient),
|
||||
zrevrangebyscore: util.promisify(redisClient.zrevrangebyscore).bind(redisClient),
|
||||
zscore: util.promisify(redisClient.zscore).bind(redisClient),
|
||||
zcount: util.promisify(redisClient.zcount).bind(redisClient),
|
||||
zcard: util.promisify(redisClient.zcard).bind(redisClient),
|
||||
zrank: util.promisify(redisClient.zrank).bind(redisClient),
|
||||
zrevrank: util.promisify(redisClient.zrevrank).bind(redisClient),
|
||||
zincrby: util.promisify(redisClient.zincrby).bind(redisClient),
|
||||
|
||||
zrangebylex: util.promisify(redisClient.zrangebylex).bind(redisClient),
|
||||
zrevrangebylex: util.promisify(redisClient.zrevrangebylex).bind(redisClient),
|
||||
zremrangebylex: util.promisify(redisClient.zremrangebylex).bind(redisClient),
|
||||
zlexcount: util.promisify(redisClient.zlexcount).bind(redisClient),
|
||||
|
||||
lpush: util.promisify(redisClient.lpush).bind(redisClient),
|
||||
rpush: util.promisify(redisClient.rpush).bind(redisClient),
|
||||
rpop: util.promisify(redisClient.rpop).bind(redisClient),
|
||||
lrem: util.promisify(redisClient.lrem).bind(redisClient),
|
||||
ltrim: util.promisify(redisClient.ltrim).bind(redisClient),
|
||||
lrange: util.promisify(redisClient.lrange).bind(redisClient),
|
||||
llen: util.promisify(redisClient.llen).bind(redisClient),
|
||||
|
||||
};
|
||||
};
|
||||
@@ -1,33 +1,28 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (redisClient, module) {
|
||||
var helpers = module.helpers.redis;
|
||||
var helpers = require('./helpers');
|
||||
|
||||
module.setAdd = function (key, value, callback) {
|
||||
callback = callback || function () {};
|
||||
module.setAdd = async function (key, value) {
|
||||
if (!Array.isArray(value)) {
|
||||
value = [value];
|
||||
}
|
||||
if (!value.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
redisClient.sadd(key, value, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await redisClient.async.sadd(key, value);
|
||||
};
|
||||
|
||||
module.setsAdd = function (keys, value, callback) {
|
||||
callback = callback || function () {};
|
||||
module.setsAdd = async function (keys, value) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return setImmediate(callback);
|
||||
return;
|
||||
}
|
||||
helpers.execKeysValue(redisClient, 'batch', 'sadd', keys, value, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
const batch = redisClient.batch();
|
||||
keys.forEach(k => batch.sadd(String(k), String(value)));
|
||||
await helpers.execBatch(batch);
|
||||
};
|
||||
|
||||
module.setRemove = function (key, value, callback) {
|
||||
callback = callback || function () {};
|
||||
module.setRemove = async function (key, value) {
|
||||
if (!Array.isArray(value)) {
|
||||
value = [value];
|
||||
}
|
||||
@@ -36,58 +31,57 @@ module.exports = function (redisClient, module) {
|
||||
}
|
||||
|
||||
var batch = redisClient.batch();
|
||||
key.forEach(function (key) {
|
||||
batch.srem(key, value);
|
||||
});
|
||||
batch.exec(function (err) {
|
||||
callback(err);
|
||||
});
|
||||
key.forEach(k => batch.srem(String(k), value));
|
||||
await helpers.execBatch(batch);
|
||||
};
|
||||
|
||||
module.setsRemove = function (keys, value, callback) {
|
||||
callback = callback || function () {};
|
||||
helpers.execKeysValue(redisClient, 'batch', 'srem', keys, value, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
module.setsRemove = async function (keys, value) {
|
||||
var batch = redisClient.batch();
|
||||
keys.forEach(k => batch.srem(String(k), value));
|
||||
await helpers.execBatch(batch);
|
||||
};
|
||||
|
||||
module.isSetMember = function (key, value, callback) {
|
||||
redisClient.sismember(key, value, function (err, result) {
|
||||
callback(err, result === 1);
|
||||
});
|
||||
module.isSetMember = async function (key, value) {
|
||||
const result = await redisClient.async.sismember(key, value);
|
||||
return result === 1;
|
||||
};
|
||||
|
||||
module.isSetMembers = function (key, values, callback) {
|
||||
helpers.execKeyValues(redisClient, 'batch', 'sismember', key, values, function (err, results) {
|
||||
callback(err, results ? helpers.resultsToBool(results) : null);
|
||||
});
|
||||
module.isSetMembers = async function (key, values) {
|
||||
const batch = redisClient.batch();
|
||||
values.forEach(v => batch.sismember(String(key), String(v)));
|
||||
const results = await helpers.execBatch(batch);
|
||||
return results ? helpers.resultsToBool(results) : null;
|
||||
};
|
||||
|
||||
module.isMemberOfSets = function (sets, value, callback) {
|
||||
helpers.execKeysValue(redisClient, 'batch', 'sismember', sets, value, function (err, results) {
|
||||
callback(err, results ? helpers.resultsToBool(results) : null);
|
||||
});
|
||||
module.isMemberOfSets = async function (sets, value) {
|
||||
const batch = redisClient.batch();
|
||||
sets.forEach(s => batch.sismember(String(s), String(value)));
|
||||
const results = await helpers.execBatch(batch);
|
||||
return results ? helpers.resultsToBool(results) : null;
|
||||
};
|
||||
|
||||
module.getSetMembers = function (key, callback) {
|
||||
redisClient.smembers(key, callback);
|
||||
module.getSetMembers = async function (key) {
|
||||
return await redisClient.async.smembers(key);
|
||||
};
|
||||
|
||||
module.getSetsMembers = function (keys, callback) {
|
||||
helpers.execKeys(redisClient, 'batch', 'smembers', keys, callback);
|
||||
module.getSetsMembers = async function (keys) {
|
||||
const batch = redisClient.batch();
|
||||
keys.forEach(k => batch.smembers(String(k)));
|
||||
return await helpers.execBatch(batch);
|
||||
};
|
||||
|
||||
module.setCount = function (key, callback) {
|
||||
redisClient.scard(key, callback);
|
||||
module.setCount = async function (key) {
|
||||
return await redisClient.async.scard(key);
|
||||
};
|
||||
|
||||
module.setsCount = function (keys, callback) {
|
||||
helpers.execKeys(redisClient, 'batch', 'scard', keys, callback);
|
||||
module.setsCount = async function (keys) {
|
||||
const batch = redisClient.batch();
|
||||
keys.forEach(k => batch.scard(String(k)));
|
||||
return await helpers.execBatch(batch);
|
||||
};
|
||||
|
||||
module.setRemoveRandom = function (key, callback) {
|
||||
callback = callback || function () {};
|
||||
redisClient.spop(key, callback);
|
||||
module.setRemoveRandom = async function (key) {
|
||||
return await redisClient.async.spop(key);
|
||||
};
|
||||
|
||||
return module;
|
||||
|
||||
@@ -3,62 +3,55 @@
|
||||
module.exports = function (redisClient, module) {
|
||||
var _ = require('lodash');
|
||||
var utils = require('../../utils');
|
||||
|
||||
var helpers = module.helpers.redis;
|
||||
var helpers = require('./helpers');
|
||||
|
||||
require('./sorted/add')(redisClient, module);
|
||||
require('./sorted/remove')(redisClient, module);
|
||||
require('./sorted/union')(redisClient, module);
|
||||
require('./sorted/intersect')(redisClient, module);
|
||||
|
||||
module.getSortedSetRange = function (key, start, stop, callback) {
|
||||
sortedSetRange('zrange', key, start, stop, false, callback);
|
||||
module.getSortedSetRange = async function (key, start, stop) {
|
||||
return await sortedSetRange('zrange', key, start, stop, false);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRange = function (key, start, stop, callback) {
|
||||
sortedSetRange('zrevrange', key, start, stop, false, callback);
|
||||
module.getSortedSetRevRange = async function (key, start, stop) {
|
||||
return await sortedSetRange('zrevrange', key, start, stop, false);
|
||||
};
|
||||
|
||||
module.getSortedSetRangeWithScores = function (key, start, stop, callback) {
|
||||
sortedSetRange('zrange', key, start, stop, true, callback);
|
||||
module.getSortedSetRangeWithScores = async function (key, start, stop) {
|
||||
return await sortedSetRange('zrange', key, start, stop, true);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRangeWithScores = function (key, start, stop, callback) {
|
||||
sortedSetRange('zrevrange', key, start, stop, true, callback);
|
||||
module.getSortedSetRevRangeWithScores = async function (key, start, stop) {
|
||||
return await sortedSetRange('zrevrange', key, start, stop, true);
|
||||
};
|
||||
|
||||
function sortedSetRange(method, key, start, stop, withScores, callback) {
|
||||
async function sortedSetRange(method, key, start, stop, withScores) {
|
||||
if (Array.isArray(key)) {
|
||||
if (!key.length) {
|
||||
return setImmediate(callback, null, []);
|
||||
return [];
|
||||
}
|
||||
const batch = redisClient.batch();
|
||||
key.forEach((key) => {
|
||||
batch[method]([key, start, stop, 'WITHSCORES']);
|
||||
});
|
||||
batch.exec(function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
data = _.flatten(data);
|
||||
var objects = [];
|
||||
for (var i = 0; i < data.length; i += 2) {
|
||||
objects.push({ value: data[i], score: parseFloat(data[i + 1]) });
|
||||
}
|
||||
let data = await helpers.execBatch(batch);
|
||||
data = _.flatten(data);
|
||||
let objects = [];
|
||||
for (let i = 0; i < data.length; i += 2) {
|
||||
objects.push({ value: data[i], score: parseFloat(data[i + 1]) });
|
||||
}
|
||||
|
||||
objects.sort((a, b) => {
|
||||
if (method === 'zrange') {
|
||||
return a.score - b.score;
|
||||
}
|
||||
return b.score - a.score;
|
||||
});
|
||||
if (withScores) {
|
||||
return callback(null, objects);
|
||||
objects.sort((a, b) => {
|
||||
if (method === 'zrange') {
|
||||
return a.score - b.score;
|
||||
}
|
||||
objects = objects.map(item => item.value);
|
||||
callback(null, objects);
|
||||
return b.score - a.score;
|
||||
});
|
||||
return;
|
||||
if (!withScores) {
|
||||
objects = objects.map(item => item.value);
|
||||
}
|
||||
return objects;
|
||||
}
|
||||
|
||||
var params = [key, start, stop];
|
||||
@@ -66,238 +59,193 @@ module.exports = function (redisClient, module) {
|
||||
params.push('WITHSCORES');
|
||||
}
|
||||
|
||||
redisClient[method](params, function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
if (!withScores) {
|
||||
return callback(null, data);
|
||||
}
|
||||
var objects = [];
|
||||
for (var i = 0; i < data.length; i += 2) {
|
||||
objects.push({ value: data[i], score: parseFloat(data[i + 1]) });
|
||||
}
|
||||
callback(null, objects);
|
||||
});
|
||||
const data = await redisClient.async[method](params);
|
||||
if (!withScores) {
|
||||
return data;
|
||||
}
|
||||
const objects = [];
|
||||
for (var i = 0; i < data.length; i += 2) {
|
||||
objects.push({ value: data[i], score: parseFloat(data[i + 1]) });
|
||||
}
|
||||
return objects;
|
||||
}
|
||||
|
||||
module.getSortedSetRangeByScore = function (key, start, count, min, max, callback) {
|
||||
redisClient.zrangebyscore([key, min, max, 'LIMIT', start, count], callback);
|
||||
module.getSortedSetRangeByScore = async function (key, start, count, min, max) {
|
||||
return await redisClient.async.zrangebyscore([key, min, max, 'LIMIT', start, count]);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRangeByScore = function (key, start, count, max, min, callback) {
|
||||
redisClient.zrevrangebyscore([key, max, min, 'LIMIT', start, count], callback);
|
||||
module.getSortedSetRevRangeByScore = async function (key, start, count, max, min) {
|
||||
return await redisClient.async.zrevrangebyscore([key, max, min, 'LIMIT', start, count]);
|
||||
};
|
||||
|
||||
module.getSortedSetRangeByScoreWithScores = function (key, start, count, min, max, callback) {
|
||||
sortedSetRangeByScoreWithScores('zrangebyscore', key, start, count, min, max, callback);
|
||||
module.getSortedSetRangeByScoreWithScores = async function (key, start, count, min, max) {
|
||||
return await sortedSetRangeByScoreWithScores('zrangebyscore', key, start, count, min, max);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRangeByScoreWithScores = function (key, start, count, max, min, callback) {
|
||||
sortedSetRangeByScoreWithScores('zrevrangebyscore', key, start, count, max, min, callback);
|
||||
module.getSortedSetRevRangeByScoreWithScores = async function (key, start, count, max, min) {
|
||||
return await sortedSetRangeByScoreWithScores('zrevrangebyscore', key, start, count, max, min);
|
||||
};
|
||||
|
||||
function sortedSetRangeByScoreWithScores(method, key, start, count, min, max, callback) {
|
||||
redisClient[method]([key, min, max, 'WITHSCORES', 'LIMIT', start, count], function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
var objects = [];
|
||||
for (var i = 0; i < data.length; i += 2) {
|
||||
objects.push({ value: data[i], score: parseFloat(data[i + 1]) });
|
||||
}
|
||||
callback(null, objects);
|
||||
});
|
||||
async function sortedSetRangeByScoreWithScores(method, key, start, count, min, max) {
|
||||
const data = await redisClient.async[method]([key, min, max, 'WITHSCORES', 'LIMIT', start, count]);
|
||||
const objects = [];
|
||||
for (var i = 0; i < data.length; i += 2) {
|
||||
objects.push({ value: data[i], score: parseFloat(data[i + 1]) });
|
||||
}
|
||||
return objects;
|
||||
}
|
||||
|
||||
module.sortedSetCount = function (key, min, max, callback) {
|
||||
redisClient.zcount(key, min, max, callback);
|
||||
module.sortedSetCount = async function (key, min, max) {
|
||||
return await redisClient.async.zcount(key, min, max);
|
||||
};
|
||||
|
||||
module.sortedSetCard = function (key, callback) {
|
||||
redisClient.zcard(key, callback);
|
||||
module.sortedSetCard = async function (key) {
|
||||
return await redisClient.async.zcard(key);
|
||||
};
|
||||
|
||||
module.sortedSetsCard = function (keys, callback) {
|
||||
module.sortedSetsCard = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
var batch = redisClient.batch();
|
||||
for (var i = 0; i < keys.length; i += 1) {
|
||||
batch.zcard(keys[i]);
|
||||
}
|
||||
batch.exec(callback);
|
||||
keys.forEach(k => batch.zcard(String(k)));
|
||||
return await helpers.execBatch(batch);
|
||||
};
|
||||
|
||||
module.sortedSetsCardSum = function (keys, callback) {
|
||||
module.sortedSetsCardSum = async function (keys) {
|
||||
if (!keys || (Array.isArray(keys) && !keys.length)) {
|
||||
return callback(null, 0);
|
||||
return 0;
|
||||
}
|
||||
if (!Array.isArray(keys)) {
|
||||
keys = [keys];
|
||||
}
|
||||
module.sortedSetsCard(keys, function (err, counts) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
const sum = counts.reduce(function (acc, val) { return acc + val; }, 0);
|
||||
callback(null, sum);
|
||||
});
|
||||
const counts = await module.sortedSetsCard(keys);
|
||||
const sum = counts.reduce((acc, val) => acc + val, 0);
|
||||
return sum;
|
||||
};
|
||||
|
||||
module.sortedSetRank = function (key, value, callback) {
|
||||
redisClient.zrank(key, value, callback);
|
||||
module.sortedSetRank = async function (key, value) {
|
||||
return await redisClient.async.zrank(key, value);
|
||||
};
|
||||
|
||||
module.sortedSetRevRank = function (key, value, callback) {
|
||||
redisClient.zrevrank(key, value, callback);
|
||||
module.sortedSetRevRank = async function (key, value) {
|
||||
return await redisClient.async.zrevrank(key, value);
|
||||
};
|
||||
|
||||
module.sortedSetsRanks = function (keys, values, callback) {
|
||||
var batch = redisClient.batch();
|
||||
module.sortedSetsRanks = async function (keys, values) {
|
||||
const batch = redisClient.batch();
|
||||
for (var i = 0; i < values.length; i += 1) {
|
||||
batch.zrank(keys[i], values[i]);
|
||||
batch.zrank(keys[i], String(values[i]));
|
||||
}
|
||||
batch.exec(callback);
|
||||
return await helpers.execBatch(batch);
|
||||
};
|
||||
|
||||
module.sortedSetsRevRanks = function (keys, values, callback) {
|
||||
var batch = redisClient.batch();
|
||||
module.sortedSetsRevRanks = async function (keys, values) {
|
||||
const batch = redisClient.batch();
|
||||
for (var i = 0; i < values.length; i += 1) {
|
||||
batch.zrevrank(keys[i], values[i]);
|
||||
batch.zrevrank(keys[i], String(values[i]));
|
||||
}
|
||||
batch.exec(callback);
|
||||
return await helpers.execBatch(batch);
|
||||
};
|
||||
|
||||
module.sortedSetRanks = function (key, values, callback) {
|
||||
var batch = redisClient.batch();
|
||||
module.sortedSetRanks = async function (key, values) {
|
||||
const batch = redisClient.batch();
|
||||
for (var i = 0; i < values.length; i += 1) {
|
||||
batch.zrank(key, values[i]);
|
||||
batch.zrank(key, String(values[i]));
|
||||
}
|
||||
batch.exec(callback);
|
||||
return await helpers.execBatch(batch);
|
||||
};
|
||||
|
||||
module.sortedSetRevRanks = function (key, values, callback) {
|
||||
var batch = redisClient.batch();
|
||||
module.sortedSetRevRanks = async function (key, values) {
|
||||
const batch = redisClient.batch();
|
||||
for (var i = 0; i < values.length; i += 1) {
|
||||
batch.zrevrank(key, values[i]);
|
||||
batch.zrevrank(key, String(values[i]));
|
||||
}
|
||||
batch.exec(callback);
|
||||
return await helpers.execBatch(batch);
|
||||
};
|
||||
|
||||
module.sortedSetScore = function (key, value, callback) {
|
||||
module.sortedSetScore = async function (key, value) {
|
||||
if (!key || value === undefined) {
|
||||
return callback(null, null);
|
||||
return null;
|
||||
}
|
||||
|
||||
redisClient.zscore(key, value, function (err, score) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
if (score === null) {
|
||||
return callback(null, score);
|
||||
}
|
||||
callback(null, parseFloat(score));
|
||||
});
|
||||
const score = await redisClient.async.zscore(key, value);
|
||||
return score === null ? score : parseFloat(score);
|
||||
};
|
||||
|
||||
module.sortedSetsScore = function (keys, value, callback) {
|
||||
module.sortedSetsScore = async function (keys, value) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
helpers.execKeysValue(redisClient, 'batch', 'zscore', keys, value, function (err, scores) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
scores = scores.map(function (d) {
|
||||
return d === null ? d : parseFloat(d);
|
||||
});
|
||||
callback(null, scores);
|
||||
});
|
||||
const batch = redisClient.batch();
|
||||
keys.forEach(key => batch.zscore(String(key), String(value)));
|
||||
const scores = await helpers.execBatch(batch);
|
||||
return scores.map(d => (d === null ? d : parseFloat(d)));
|
||||
};
|
||||
|
||||
module.sortedSetScores = function (key, values, callback) {
|
||||
module.sortedSetScores = async function (key, values) {
|
||||
if (!values.length) {
|
||||
return setImmediate(callback, null, []);
|
||||
return [];
|
||||
}
|
||||
helpers.execKeyValues(redisClient, 'batch', 'zscore', key, values, function (err, scores) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
scores = scores.map(function (d) {
|
||||
return d === null ? d : parseFloat(d);
|
||||
});
|
||||
callback(null, scores);
|
||||
});
|
||||
const batch = redisClient.batch();
|
||||
values.forEach(value => batch.zscore(String(key), String(value)));
|
||||
const scores = await helpers.execBatch(batch);
|
||||
return scores.map(d => (d === null ? d : parseFloat(d)));
|
||||
};
|
||||
|
||||
module.isSortedSetMember = function (key, value, callback) {
|
||||
module.sortedSetScore(key, value, function (err, score) {
|
||||
callback(err, utils.isNumber(score));
|
||||
});
|
||||
module.isSortedSetMember = async function (key, value) {
|
||||
const score = await module.sortedSetScore(key, value);
|
||||
return utils.isNumber(score);
|
||||
};
|
||||
|
||||
module.isSortedSetMembers = function (key, values, callback) {
|
||||
helpers.execKeyValues(redisClient, 'batch', 'zscore', key, values, function (err, results) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
callback(null, results.map(Boolean));
|
||||
});
|
||||
module.isSortedSetMembers = async function (key, values) {
|
||||
const batch = redisClient.batch();
|
||||
values.forEach(v => batch.zscore(key, String(v)));
|
||||
const results = await helpers.execBatch(batch);
|
||||
return results.map(utils.isNumber);
|
||||
};
|
||||
|
||||
module.isMemberOfSortedSets = function (keys, value, callback) {
|
||||
module.isMemberOfSortedSets = async function (keys, value) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return setImmediate(callback, null, []);
|
||||
return [];
|
||||
}
|
||||
helpers.execKeysValue(redisClient, 'batch', 'zscore', keys, value, function (err, results) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
callback(null, results.map(Boolean));
|
||||
});
|
||||
const batch = redisClient.batch();
|
||||
keys.forEach(k => batch.zscore(k, String(value)));
|
||||
const results = await helpers.execBatch(batch);
|
||||
return results.map(utils.isNumber);
|
||||
};
|
||||
|
||||
module.getSortedSetsMembers = function (keys, callback) {
|
||||
module.getSortedSetsMembers = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return setImmediate(callback, null, []);
|
||||
return [];
|
||||
}
|
||||
var batch = redisClient.batch();
|
||||
for (var i = 0; i < keys.length; i += 1) {
|
||||
batch.zrange(keys[i], 0, -1);
|
||||
}
|
||||
batch.exec(callback);
|
||||
keys.forEach(k => batch.zrange(k, 0, -1));
|
||||
return await helpers.execBatch(batch);
|
||||
};
|
||||
|
||||
module.sortedSetIncrBy = function (key, increment, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
redisClient.zincrby(key, increment, value, function (err, newValue) {
|
||||
callback(err, !err ? parseFloat(newValue) : undefined);
|
||||
});
|
||||
module.sortedSetIncrBy = async function (key, increment, value) {
|
||||
const newValue = await redisClient.async.zincrby(key, increment, value);
|
||||
return parseFloat(newValue);
|
||||
};
|
||||
|
||||
module.getSortedSetRangeByLex = function (key, min, max, start, count, callback) {
|
||||
sortedSetLex('zrangebylex', false, key, min, max, start, count, callback);
|
||||
module.getSortedSetRangeByLex = async function (key, min, max, start, count) {
|
||||
return await sortedSetLex('zrangebylex', false, key, min, max, start, count);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRangeByLex = function (key, max, min, start, count, callback) {
|
||||
sortedSetLex('zrevrangebylex', true, key, max, min, start, count, callback);
|
||||
module.getSortedSetRevRangeByLex = async function (key, max, min, start, count) {
|
||||
return await sortedSetLex('zrevrangebylex', true, key, max, min, start, count);
|
||||
};
|
||||
|
||||
module.sortedSetRemoveRangeByLex = function (key, min, max, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
sortedSetLex('zremrangebylex', false, key, min, max, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
module.sortedSetRemoveRangeByLex = async function (key, min, max) {
|
||||
await sortedSetLex('zremrangebylex', false, key, min, max);
|
||||
};
|
||||
|
||||
module.sortedSetLexCount = function (key, min, max, callback) {
|
||||
sortedSetLex('zlexcount', false, key, min, max, callback);
|
||||
module.sortedSetLexCount = async function (key, min, max) {
|
||||
return await sortedSetLex('zlexcount', false, key, min, max);
|
||||
};
|
||||
|
||||
function sortedSetLex(method, reverse, key, min, max, start, count, callback) {
|
||||
callback = callback || start;
|
||||
|
||||
async function sortedSetLex(method, reverse, key, min, max, start, count) {
|
||||
var minmin;
|
||||
var maxmax;
|
||||
if (reverse) {
|
||||
@@ -314,11 +262,10 @@ module.exports = function (redisClient, module) {
|
||||
if (max !== maxmax && !max.match(/^[[(]/)) {
|
||||
max = '[' + max;
|
||||
}
|
||||
|
||||
const args = [key, min, max];
|
||||
if (count) {
|
||||
redisClient[method]([key, min, max, 'LIMIT', start, count], callback);
|
||||
} else {
|
||||
redisClient[method]([key, min, max], callback);
|
||||
args.push('LIMIT', start, count);
|
||||
}
|
||||
return await redisClient.async[method](args);
|
||||
}
|
||||
};
|
||||
|
||||
@@ -1,83 +1,72 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (redisClient, module) {
|
||||
const helpers = require('../helpers');
|
||||
const utils = require('../../../utils');
|
||||
|
||||
module.sortedSetAdd = function (key, score, value, callback) {
|
||||
callback = callback || function () {};
|
||||
module.sortedSetAdd = async function (key, score, value) {
|
||||
if (!key) {
|
||||
return setImmediate(callback);
|
||||
return;
|
||||
}
|
||||
if (Array.isArray(score) && Array.isArray(value)) {
|
||||
return sortedSetAddMulti(key, score, value, callback);
|
||||
return await sortedSetAddMulti(key, score, value);
|
||||
}
|
||||
if (!utils.isNumber(score)) {
|
||||
return setImmediate(callback, new Error('[[error:invalid-score, ' + score + ']]'));
|
||||
throw new Error('[[error:invalid-score, ' + score + ']]');
|
||||
}
|
||||
redisClient.zadd(key, score, String(value), function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await redisClient.async.zadd(key, score, String(value));
|
||||
};
|
||||
|
||||
function sortedSetAddMulti(key, scores, values, callback) {
|
||||
async function sortedSetAddMulti(key, scores, values) {
|
||||
if (!scores.length || !values.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
if (scores.length !== values.length) {
|
||||
return callback(new Error('[[error:invalid-data]]'));
|
||||
throw new Error('[[error:invalid-data]]');
|
||||
}
|
||||
for (let i = 0; i < scores.length; i += 1) {
|
||||
if (!utils.isNumber(scores[i])) {
|
||||
return setImmediate(callback, new Error('[[error:invalid-score, ' + scores[i] + ']]'));
|
||||
throw new Error('[[error:invalid-score, ' + scores[i] + ']]');
|
||||
}
|
||||
}
|
||||
var args = [key];
|
||||
|
||||
for (var i = 0; i < scores.length; i += 1) {
|
||||
args.push(scores[i], String(values[i]));
|
||||
}
|
||||
|
||||
redisClient.zadd(args, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await redisClient.async.zadd(args);
|
||||
}
|
||||
|
||||
module.sortedSetsAdd = function (keys, scores, value, callback) {
|
||||
callback = callback || function () {};
|
||||
module.sortedSetsAdd = async function (keys, scores, value) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return setImmediate(callback);
|
||||
return;
|
||||
}
|
||||
const isArrayOfScores = Array.isArray(scores);
|
||||
if (!isArrayOfScores && !utils.isNumber(scores)) {
|
||||
return setImmediate(callback, new Error('[[error:invalid-score, ' + scores + ']]'));
|
||||
throw new Error('[[error:invalid-score, ' + scores + ']]');
|
||||
}
|
||||
|
||||
if (isArrayOfScores && scores.length !== keys.length) {
|
||||
return setImmediate(callback, new Error('[[error:invalid-data]]'));
|
||||
throw new Error('[[error:invalid-data]]');
|
||||
}
|
||||
|
||||
var batch = redisClient.batch();
|
||||
|
||||
for (var i = 0; i < keys.length; i += 1) {
|
||||
if (keys[i]) {
|
||||
batch.zadd(keys[i], isArrayOfScores ? scores[i] : scores, String(value));
|
||||
}
|
||||
}
|
||||
|
||||
batch.exec(function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await helpers.execBatch(batch);
|
||||
};
|
||||
|
||||
module.sortedSetAddBulk = function (data, callback) {
|
||||
module.sortedSetAddBulk = async function (data) {
|
||||
if (!Array.isArray(data) || !data.length) {
|
||||
return setImmediate(callback);
|
||||
return;
|
||||
}
|
||||
var batch = redisClient.batch();
|
||||
data.forEach(function (item) {
|
||||
batch.zadd(item[0], item[1], item[2]);
|
||||
});
|
||||
batch.exec(err => callback(err));
|
||||
await helpers.execBatch(batch);
|
||||
};
|
||||
};
|
||||
|
||||
@@ -2,9 +2,10 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (redisClient, module) {
|
||||
module.sortedSetIntersectCard = function (keys, callback) {
|
||||
const helpers = require('../helpers');
|
||||
module.sortedSetIntersectCard = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, 0);
|
||||
return 0;
|
||||
}
|
||||
var tempSetName = 'temp_' + Date.now();
|
||||
|
||||
@@ -14,26 +15,21 @@ module.exports = function (redisClient, module) {
|
||||
multi.zinterstore(interParams);
|
||||
multi.zcard(tempSetName);
|
||||
multi.del(tempSetName);
|
||||
multi.exec(function (err, results) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
callback(null, results[1] || 0);
|
||||
});
|
||||
const results = await helpers.execBatch(multi);
|
||||
return results[1] || 0;
|
||||
};
|
||||
|
||||
module.getSortedSetIntersect = function (params, callback) {
|
||||
module.getSortedSetIntersect = async function (params) {
|
||||
params.method = 'zrange';
|
||||
getSortedSetRevIntersect(params, callback);
|
||||
return await getSortedSetRevIntersect(params);
|
||||
};
|
||||
|
||||
module.getSortedSetRevIntersect = function (params, callback) {
|
||||
module.getSortedSetRevIntersect = async function (params) {
|
||||
params.method = 'zrevrange';
|
||||
getSortedSetRevIntersect(params, callback);
|
||||
return await getSortedSetRevIntersect(params);
|
||||
};
|
||||
|
||||
function getSortedSetRevIntersect(params, callback) {
|
||||
async function getSortedSetRevIntersect(params) {
|
||||
var sets = params.sets;
|
||||
var start = params.hasOwnProperty('start') ? params.start : 0;
|
||||
var stop = params.hasOwnProperty('stop') ? params.stop : -1;
|
||||
@@ -59,20 +55,16 @@ module.exports = function (redisClient, module) {
|
||||
multi.zinterstore(interParams);
|
||||
multi[params.method](rangeParams);
|
||||
multi.del(tempSetName);
|
||||
multi.exec(function (err, results) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
let results = await helpers.execBatch(multi);
|
||||
|
||||
if (!params.withScores) {
|
||||
return callback(null, results ? results[1] : null);
|
||||
}
|
||||
results = results[1] || [];
|
||||
var objects = [];
|
||||
for (var i = 0; i < results.length; i += 2) {
|
||||
objects.push({ value: results[i], score: parseFloat(results[i + 1]) });
|
||||
}
|
||||
callback(null, objects);
|
||||
});
|
||||
if (!params.withScores) {
|
||||
return results ? results[1] : null;
|
||||
}
|
||||
results = results[1] || [];
|
||||
var objects = [];
|
||||
for (var i = 0; i < results.length; i += 2) {
|
||||
objects.push({ value: results[i], score: parseFloat(results[i + 1]) });
|
||||
}
|
||||
return objects;
|
||||
}
|
||||
};
|
||||
|
||||
@@ -2,46 +2,36 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (redisClient, module) {
|
||||
var helpers = module.helpers.redis;
|
||||
var helpers = require('../helpers');
|
||||
|
||||
module.sortedSetRemove = function (key, value, callback) {
|
||||
callback = callback || function () {};
|
||||
if (!value) {
|
||||
return callback();
|
||||
module.sortedSetRemove = async function (key, value) {
|
||||
if (!key) {
|
||||
return;
|
||||
}
|
||||
if (!Array.isArray(value)) {
|
||||
const isValueArray = Array.isArray(value);
|
||||
if (!value || (isValueArray && !value.length)) {
|
||||
return;
|
||||
}
|
||||
if (!isValueArray) {
|
||||
value = [value];
|
||||
}
|
||||
|
||||
if (Array.isArray(key)) {
|
||||
var batch = redisClient.batch();
|
||||
key.forEach(function (key) {
|
||||
batch.zrem(key, value);
|
||||
});
|
||||
batch.exec(function (err) {
|
||||
callback(err);
|
||||
});
|
||||
const batch = redisClient.batch();
|
||||
key.forEach(k => batch.zrem(k, value));
|
||||
await helpers.execBatch(batch);
|
||||
} else {
|
||||
helpers.execKeyValues(redisClient, 'batch', 'zrem', key, value, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await redisClient.async.zrem(key, value);
|
||||
}
|
||||
};
|
||||
|
||||
module.sortedSetsRemove = function (keys, value, callback) {
|
||||
helpers.execKeysValue(redisClient, 'batch', 'zrem', keys, value, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
module.sortedSetsRemove = async function (keys, value) {
|
||||
await module.sortedSetRemove(keys, value);
|
||||
};
|
||||
|
||||
module.sortedSetsRemoveRangeByScore = function (keys, min, max, callback) {
|
||||
callback = callback || function () {};
|
||||
module.sortedSetsRemoveRangeByScore = async function (keys, min, max) {
|
||||
var batch = redisClient.batch();
|
||||
for (var i = 0; i < keys.length; i += 1) {
|
||||
batch.zremrangebyscore(keys[i], min, max);
|
||||
}
|
||||
batch.exec(function (err) {
|
||||
callback(err);
|
||||
});
|
||||
keys.forEach(k => batch.zremrangebyscore(k, min, max));
|
||||
await helpers.execBatch(batch);
|
||||
};
|
||||
};
|
||||
|
||||
@@ -2,37 +2,33 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (redisClient, module) {
|
||||
module.sortedSetUnionCard = function (keys, callback) {
|
||||
const helpers = require('../helpers');
|
||||
module.sortedSetUnionCard = async function (keys) {
|
||||
var tempSetName = 'temp_' + Date.now();
|
||||
if (!keys.length) {
|
||||
return setImmediate(callback, null, 0);
|
||||
return 0;
|
||||
}
|
||||
var multi = redisClient.multi();
|
||||
multi.zunionstore([tempSetName, keys.length].concat(keys));
|
||||
multi.zcard(tempSetName);
|
||||
multi.del(tempSetName);
|
||||
multi.exec(function (err, results) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
callback(null, Array.isArray(results) && results.length ? results[1] : 0);
|
||||
});
|
||||
const results = await helpers.execBatch(multi);
|
||||
return Array.isArray(results) && results.length ? results[1] : 0;
|
||||
};
|
||||
|
||||
module.getSortedSetUnion = function (params, callback) {
|
||||
module.getSortedSetUnion = async function (params) {
|
||||
params.method = 'zrange';
|
||||
module.sortedSetUnion(params, callback);
|
||||
return await module.sortedSetUnion(params);
|
||||
};
|
||||
|
||||
module.getSortedSetRevUnion = function (params, callback) {
|
||||
module.getSortedSetRevUnion = async function (params) {
|
||||
params.method = 'zrevrange';
|
||||
module.sortedSetUnion(params, callback);
|
||||
return await module.sortedSetUnion(params);
|
||||
};
|
||||
|
||||
module.sortedSetUnion = function (params, callback) {
|
||||
module.sortedSetUnion = async function (params) {
|
||||
if (!params.sets.length) {
|
||||
return setImmediate(callback, null, []);
|
||||
return [];
|
||||
}
|
||||
|
||||
var tempSetName = 'temp_' + Date.now();
|
||||
@@ -46,19 +42,15 @@ module.exports = function (redisClient, module) {
|
||||
multi.zunionstore([tempSetName, params.sets.length].concat(params.sets));
|
||||
multi[params.method](rangeParams);
|
||||
multi.del(tempSetName);
|
||||
multi.exec(function (err, results) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
if (!params.withScores) {
|
||||
return callback(null, results ? results[1] : null);
|
||||
}
|
||||
results = results[1] || [];
|
||||
var objects = [];
|
||||
for (var i = 0; i < results.length; i += 2) {
|
||||
objects.push({ value: results[i], score: parseFloat(results[i + 1]) });
|
||||
}
|
||||
callback(null, objects);
|
||||
});
|
||||
let results = await helpers.execBatch(multi);
|
||||
if (!params.withScores) {
|
||||
return results ? results[1] : null;
|
||||
}
|
||||
results = results[1] || [];
|
||||
var objects = [];
|
||||
for (var i = 0; i < results.length; i += 2) {
|
||||
objects.push({ value: results[i], score: parseFloat(results[i + 1]) });
|
||||
}
|
||||
return objects;
|
||||
};
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user