use SQL's limit/offset pagination for nextIndex/maxCount requests (#185)

Instead of retrieving the entire list of items/characters/scores/etc. at once (and even store them in memory), use SQL's `LIMIT ... OFFSET ...` pagination so we only take what we need.

Currently only CHUNITHM uses this, but this will also affect maimai DX and O.N.G.E.K.I. once the PR is ready.

Also snuck in a fix for CHUNITHM/maimai DX's `GetUserRivalMusicApi` to respect the `userRivalMusicLevelList` sent by the client.

### How this works

Say we have a `GetUserCharacterApi` request:

```json
{
    "userId": 10000,
    "maxCount": 700,
    "nextIndex": 0
}
```

Instead of getting the entire character list from the database (which can be very large if the user force unlocked everything), add limit/offset to the query:

```python
select(character)
.where(character.c.user == user_id)
.order_by(character.c.id.asc())
.limit(max_count + 1)
.offset(next_index)
```

The query takes `maxCount + 1` items from the database to determine if there is more items than can be returned:

```python
rows = ...

if len(rows) > max_count:
    # return only max_count rows
    next_index += max_count
else:
    # return everything left
    next_index = -1
```

This has the benefit of not needing to load everything into memory (and also having to store server state, as seen in the [`SCORE_BUFFER` list](2274b42358/titles/chuni/base.py (L13)).)

Reviewed-on: https://gitea.tendokyu.moe/Hay1tsme/artemis/pulls/185
Co-authored-by: beerpsi <beerpsi@duck.com>
Co-committed-by: beerpsi <beerpsi@duck.com>

titles/mai2/schema/score.py

@@ -1,15 +1,15 @@
 from typing import Dict, List, Optional
-from sqlalchemy import Table, Column, UniqueConstraint, PrimaryKeyConstraint, and_
-from sqlalchemy.types import Integer, String, TIMESTAMP, Boolean, JSON, BigInteger
+
+from sqlalchemy import Column, Table, UniqueConstraint, and_
+from sqlalchemy.dialects.mysql import insert
+from sqlalchemy.engine import Row
 from sqlalchemy.schema import ForeignKey
 from sqlalchemy.sql import func, select
-from sqlalchemy.engine import Row
-from sqlalchemy.dialects.mysql import insert
+from sqlalchemy.types import JSON, BigInteger, Boolean, Integer, String
 
 from core.data.schema import BaseData, metadata
-from core.data import cached
 
-best_score = Table(
+best_score: Table = Table(
     "mai2_score_best",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
@@ -272,7 +272,7 @@ playlog_old = Table(
     mysql_charset="utf8mb4",
 )
 
-best_score_old = Table(
+best_score_old: Table = Table(
     "maimai_score_best",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
@@ -313,22 +313,55 @@ class Mai2ScoreData(BaseData):
             return None
         return result.lastrowid
 
-    @cached(2)
-    async def get_best_scores(self, user_id: int, song_id: int = None, is_dx: bool = True) -> Optional[List[Row]]:
+    async def get_best_scores(
+        self,
+        user_id: int,
+        song_id: Optional[int] = None,
+        is_dx: bool = True,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        levels: Optional[list[int]] = None,
+    ) -> Optional[List[Row]]:
         if is_dx:
-            sql = best_score.select(
-                and_(
-                    best_score.c.user == user_id,
-                    (best_score.c.musicId == song_id) if song_id is not None else True,
-                )
-            ).order_by(best_score.c.musicId).order_by(best_score.c.level)
+            table = best_score
         else:
-            sql = best_score_old.select(
-                and_(
-                    best_score_old.c.user == user_id,
-                    (best_score_old.c.musicId == song_id) if song_id is not None else True,
-                )
-            ).order_by(best_score.c.musicId).order_by(best_score.c.level)
+            table = best_score_old
+
+        cond = table.c.user == user_id
+
+        if song_id is not None:
+            cond &= table.c.musicId == song_id
+        
+        if levels is not None:
+            cond &= table.c.level.in_(levels)
+        
+        if limit is None and offset is None:
+            sql = (
+                select(table)
+                .where(cond)
+                .order_by(table.c.musicId, table.c.level)
+            )
+        else:
+            subq = (
+                select(table.c.musicId)
+                .distinct()
+                .where(cond)
+                .order_by(table.c.musicId)
+            )
+
+            if limit is not None:
+                subq = subq.limit(limit)
+            if offset is not None:
+                subq = subq.offset(offset)
+            
+            subq = subq.subquery()
+
+            sql = (
+                select(table)
+                .join(subq, table.c.musicId == subq.c.musicId)
+                .where(cond)
+                .order_by(table.c.musicId, table.c.level)
+            )
 
         result = await self.execute(sql)
         if result is None: