Nemcio/NodeBB
1
0
Fork 0
mirror of https://github.com/NodeBB/NodeBB.git synced 2025-10-26 08:36:12 +01:00
Code Issues Packages Projects Releases Wiki Activity

feat: allow passing min,max to sortedSetsCardSum

Browse Source 
to get rid of multiple db calls in profile page
This commit is contained in:
Barış Soner Uşaklı
2024-06-07 19:14:13 -04:00
parent 6bbe3d1c4c
commit 70b4a0e2ae
5 changed files with 99 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/controllers/accounts/helpers.js
View File

@@ -180,8 +180,8 @@ async function getCounts(userData, callerUID) {
const cids = await categories.getCidsByPrivilege('categories:cid', callerUID, 'topics:read');
const promises = {
posts: db.sortedSetsCardSum(cids.map(c => `cid:${c}:uid:${uid}:pids`)),
best: Promise.all(cids.map(async c => db.sortedSetCount(`cid:${c}:uid:${uid}:pids:votes`, 1, '+inf'))),
controversial: Promise.all(cids.map(async c => db.sortedSetCount(`cid:${c}:uid:${uid}:pids:votes`, '-inf', -1))),
best: db.sortedSetsCardSum(cids.map(c => `cid:${c}:uid:${uid}:pids:votes`), 1, '+inf'),
controversial: db.sortedSetsCardSum(cids.map(c => `cid:${c}:uid:${uid}:pids:votes`), '-inf', -1),
topics: db.sortedSetsCardSum(cids.map(c => `cid:${c}:uid:${uid}:tids`)),
};
if (userData.isAdmin || userData.isSelf) {
@@ -196,8 +196,6 @@ async function getCounts(userData, callerUID) {
promises.blocks = user.getUserField(userData.uid, 'blocksCount');
}
const counts = await utils.promiseParallel(promises);
counts.best = counts.best.reduce((sum, count) => sum + count, 0);
counts.controversial = counts.controversial.reduce((sum, count) => sum + count, 0);
counts.categoriesWatched = counts.categoriesWatched && counts.categoriesWatched.length;
counts.groups = userData.groups.length;
counts.following = userData.followingCount;

26
src/database/mongo/sorted.js
View File

@@ -157,33 +157,39 @@ module.exports = function (module) {
query.score.$lte = max;
}
const count = await module.client.collection('objects').countDocuments(query);
return count || 0;
return await module.client.collection('objects').countDocuments(query);
};
module.sortedSetCard = async function (key) {
if (!key) {
return 0;
}
const count = await module.client.collection('objects').countDocuments({ _key: key });
return parseInt(count, 10) || 0;
return await module.client.collection('objects').countDocuments({ _key: key });
};
module.sortedSetsCard = async function (keys) {
if (!Array.isArray(keys) || !keys.length) {
return [];
}
const promises = keys.map(k => module.sortedSetCard(k));
return await Promise.all(promises);
return await Promise.all(keys.map(module.sortedSetCard));
};
module.sortedSetsCardSum = async function (keys) {
if (!keys || (Array.isArray(keys) && !keys.length)) {
module.sortedSetsCardSum = async function (keys, min = '-inf', max = '+inf') {
const isArray = Array.isArray(keys);
if (!keys || (isArray && !keys.length)) {
return 0;
}
const count = await module.client.collection('objects').countDocuments({ _key: Array.isArray(keys) ? { $in: keys } : keys });
return parseInt(count, 10) || 0;
const query = { _key: isArray ? { $in: keys } : keys };
if (min !== '-inf') {
query.score = { $gte: min };
}
if (max !== '+inf') {
query.score = query.score || {};
query.score.$lte = max;
}
return await module.client.collection('objects').countDocuments(query);
};
module.sortedSetRank = async function (key, value) {

34
src/database/postgres/sorted.js
View File

@@ -221,16 +221,42 @@ SELECT o."_key" k,
return keys.map(k => parseInt((res.rows.find(r => r.k === k) || { c: 0 }).c, 10));
};
module.sortedSetsCardSum = async function (keys) {
module.sortedSetsCardSum = async function (keys, min = '-inf', max = '+inf') {
if (!keys || (Array.isArray(keys) && !keys.length)) {
return 0;
}
if (!Array.isArray(keys)) {
keys = [keys];
}
const counts = await module.sortedSetsCard(keys);
const sum = counts.reduce((acc, val) => acc + val, 0);
return sum;
let counts = [];
if (min !== '-inf' || max !== '+inf') {
if (min === '-inf') {
min = null;
}
if (max === '+inf') {
max = null;
}
const res = await module.pool.query({
name: 'sortedSetsCardSum',
text: `
SELECT o."_key" k,
COUNT(*) c
FROM "legacy_object_live" o
INNER JOIN "legacy_zset" z
ON o."_key" = z."_key"
AND o."type" = z."type"
WHERE o."_key" = ANY($1::TEXT[])
AND (z."score" >= $2::NUMERIC OR $2::NUMERIC IS NULL)
AND (z."score" <= $3::NUMERIC OR $3::NUMERIC IS NULL)
GROUP BY o."_key"`,
values: [keys, min, max],
});
counts = keys.map(k => parseInt((res.rows.find(r => r.k === k) || { c: 0 }).c, 10));
} else {
counts = await module.sortedSetsCard(keys);
}
return counts.reduce((acc, val) => acc + val, 0);
};
module.sortedSetRank = async function (key, value) {

13
src/database/redis/sorted.js
View File

@@ -116,16 +116,21 @@ module.exports = function (module) {
return await helpers.execBatch(batch);
};
module.sortedSetsCardSum = async function (keys) {
module.sortedSetsCardSum = async function (keys, min = '-inf', max = '+inf') {
if (!keys || (Array.isArray(keys) && !keys.length)) {
return 0;
}
if (!Array.isArray(keys)) {
keys = [keys];
}
const counts = await module.sortedSetsCard(keys);
const sum = counts.reduce((acc, val) => acc + val, 0);
return sum;
const batch = module.client.batch();
if (min !== '-inf' || max !== '+inf') {
keys.forEach(k => batch.zcount(String(k), min, max));
} else {
keys.forEach(k => batch.zcard(String(k)));
}
const counts = await helpers.execBatch(batch);
return counts.reduce((acc, val) => acc + val, 0);
};
module.sortedSetRank = async function (key, value) {

91
test/database/sorted.js
View File

@@ -1,29 +1,17 @@
'use strict';
const async = require('async');
const assert = require('assert');
const db = require('../mocks/databasemock');
describe('Sorted Set methods', () => {
before((done) => {
async.parallel([
function (next) {
db.sortedSetAdd('sortedSetTest1', [1.1, 1.2, 1.3], ['value1', 'value2', 'value3'], next);
},
function (next) {
db.sortedSetAdd('sortedSetTest2', [1, 4], ['value1', 'value4'], next);
},
function (next) {
db.sortedSetAdd('sortedSetTest3', [2, 4], ['value2', 'value4'], next);
},
function (next) {
db.sortedSetAdd('sortedSetTest4', [1, 1, 2, 3, 5], ['b', 'a', 'd', 'e', 'c'], next);
},
function (next) {
db.sortedSetAdd('sortedSetLex', [0, 0, 0, 0], ['a', 'b', 'c', 'd'], next);
},
], done);
before(async () => {
await Promise.all([
db.sortedSetAdd('sortedSetTest1', [1.1, 1.2, 1.3], ['value1', 'value2', 'value3']),
db.sortedSetAdd('sortedSetTest2', [1, 4], ['value1', 'value4']),
db.sortedSetAdd('sortedSetTest3', [2, 4], ['value2', 'value4']),
db.sortedSetAdd('sortedSetTest4', [1, 1, 2, 3, 5], ['b', 'a', 'd', 'e', 'c']),
db.sortedSetAdd('sortedSetLex', [0, 0, 0, 0], ['a', 'b', 'c', 'd']),
]);
});
describe('sortedSetScan', () => {
@@ -617,6 +605,23 @@ describe('Sorted Set methods', () => {
done();
});
});
it('should work with min/max', async () => {
let count = await db.sortedSetsCardSum([
'sortedSetTest1', 'sortedSetTest2', 'sortedSetTest3',
], '-inf', 2);
assert.strictEqual(count, 5);
count = await db.sortedSetsCardSum([
'sortedSetTest1', 'sortedSetTest2', 'sortedSetTest3',
], 2, '+inf');
assert.strictEqual(count, 3);
count = await db.sortedSetsCardSum([
'sortedSetTest1', 'sortedSetTest2', 'sortedSetTest3',
], '-inf', '+inf');
assert.strictEqual(count, 7);
});
});
describe('sortedSetRank()', () => {
@@ -1225,11 +1230,11 @@ describe('Sorted Set methods', () => {
});
describe('sortedSetsRemove()', () => {
before((done) => {
async.parallel([
async.apply(db.sortedSetAdd, 'sorted4', [1, 2], ['value1', 'value2']),
async.apply(db.sortedSetAdd, 'sorted5', [1, 2], ['value1', 'value3']),
], done);
before(async () => {
await Promise.all([
db.sortedSetAdd('sorted4', [1, 2], ['value1', 'value2']),
db.sortedSetAdd('sorted5', [1, 2], ['value1', 'value3']),
]);
});
it('should remove element from multiple sorted sets', (done) => {
@@ -1278,15 +1283,11 @@ describe('Sorted Set methods', () => {
});
describe('getSortedSetIntersect', () => {
before((done) => {
async.parallel([
function (next) {
db.sortedSetAdd('interSet1', [1, 2, 3], ['value1', 'value2', 'value3'], next);
},
function (next) {
db.sortedSetAdd('interSet2', [4, 5, 6], ['value2', 'value3', 'value5'], next);
},
], done);
before(async () => {
await Promise.all([
db.sortedSetAdd('interSet1', [1, 2, 3], ['value1', 'value2', 'value3']),
db.sortedSetAdd('interSet2', [4, 5, 6], ['value2', 'value3', 'value5']),
]);
});
it('should return the intersection of two sets', (done) => {
@@ -1446,21 +1447,13 @@ describe('Sorted Set methods', () => {
});
describe('sortedSetIntersectCard', () => {
before((done) => {
async.parallel([
function (next) {
db.sortedSetAdd('interCard1', [0, 0, 0], ['value1', 'value2', 'value3'], next);
},
function (next) {
db.sortedSetAdd('interCard2', [0, 0, 0], ['value2', 'value3', 'value4'], next);
},
function (next) {
db.sortedSetAdd('interCard3', [0, 0, 0], ['value3', 'value4', 'value5'], next);
},
function (next) {
db.sortedSetAdd('interCard4', [0, 0, 0], ['value4', 'value5', 'value6'], next);
},
], done);
before(async () => {
await Promise.all([
db.sortedSetAdd('interCard1', [0, 0, 0], ['value1', 'value2', 'value3']),
db.sortedSetAdd('interCard2', [0, 0, 0], ['value2', 'value3', 'value4']),
db.sortedSetAdd('interCard3', [0, 0, 0], ['value3', 'value4', 'value5']),
db.sortedSetAdd('interCard4', [0, 0, 0], ['value4', 'value5', 'value6']),
]);
});
it('should return # of elements in intersection', (done) => {