From ea6d61ac6fb6ecdb994aa988c4be6c777f582783 Mon Sep 17 00:00:00 2001
From: Book Pauk <bookpauk@gmail.com>
Date: Sun, 23 Oct 2022 18:43:14 +0700
Subject: [PATCH] =?UTF-8?q?=D0=A0=D0=B5=D1=84=D0=B0=D0=BA=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=D0=B8=D0=BD=D0=B3?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 server/core/DbSearcher.js | 117 ++++++++++++++++++++------------------
 1 file changed, 63 insertions(+), 54 deletions(-)

diff --git a/server/core/DbSearcher.js b/server/core/DbSearcher.js
index 5b6888a..f186a2e 100644
--- a/server/core/DbSearcher.js
+++ b/server/core/DbSearcher.js
@@ -54,6 +54,61 @@ class DbSearcher {
         return where;
     }
 
+    async calcIntersect(idsArr) {
+        return await this.heavyCalc.run({
+            args: idsArr,
+            fn: (args) => {
+                //из utils.intersectSet
+                const intersectSet = (arrSet) => {
+                    if (!arrSet.length)
+                        return new Set();
+
+                    let min = 0;
+                    let size = arrSet[0].size;
+                    for (let i = 1; i < arrSet.length; i++) {
+                        if (arrSet[i].size < size) {
+                            min = i;
+                            size = arrSet[i].size;
+                        }
+                    }
+
+                    const result = new Set();
+                    for (const elem of arrSet[min]) {
+                        let inAll = true;
+                        for (let i = 0; i < arrSet.length; i++) {
+                            if (i === min)
+                                continue;
+                            if (!arrSet[i].has(elem)) {
+                                inAll = false;
+                                break;
+                            }
+                        }
+
+                        if (inAll)
+                            result.add(elem);
+                    }
+
+                    return result;
+                };
+
+                //считаем пересечение, если надо
+                let result = [];
+
+                if (args.length > 1) {
+                    const arrSet = args.map(ids => new Set(ids));
+                    result = Array.from(intersectSet(arrSet));
+                } else if (args.length == 1) {
+                    result = args[0];
+                }
+
+                //сортировка
+                result.sort((a, b) => a - b);
+
+                return result;
+            }
+        });
+    }
+
     async selectAuthorIds(query) {
         const db = this.db;
 
@@ -212,60 +267,14 @@ class DbSearcher {
         //сортировка
         authorIds.sort((a, b) => a - b);
 */
-        //ищем пересечение множеств в отдельном потоке
-        idsArr.push(authorIds);
-        authorIds = await this.heavyCalc.run({
-            args: idsArr,
-            fn: (args) => {
-                //из utils.intersectSet
-                const intersectSet = (arrSet) => {
-                    if (!arrSet.length)
-                        return new Set();
-
-                    let min = 0;
-                    let size = arrSet[0].size;
-                    for (let i = 1; i < arrSet.length; i++) {
-                        if (arrSet[i].size < size) {
-                            min = i;
-                            size = arrSet[i].size;
-                        }
-                    }
-
-                    const result = new Set();
-                    for (const elem of arrSet[min]) {
-                        let inAll = true;
-                        for (let i = 0; i < arrSet.length; i++) {
-                            if (i === min)
-                                continue;
-                            if (!arrSet[i].has(elem)) {
-                                inAll = false;
-                                break;
-                            }
-                        }
-
-                        if (inAll)
-                            result.add(elem);
-                    }
-
-                    return result;
-                };
-
-                //считаем пересечение, если надо
-                let result = [];
-
-                if (args.length > 1) {
-                    const arrSet = args.map(ids => new Set(ids));
-                    result = Array.from(intersectSet(arrSet));
-                } else if (args.length == 1) {
-                    result = args[0];
-                }
-
-                //сортировка
-                result.sort((a, b) => a - b);
-
-                return result;
-            }
-        });
+        if (idsArr.length) {
+            //ищем пересечение множеств в отдельном потоке
+            idsArr.push(authorIds);
+            authorIds = await this.calcIntersect(idsArr);
+        } else {
+            //просто сортировка
+            authorIds.sort((a, b) => a - b);
+        }
 
         return authorIds;
     }