cordscript 1.0.0__py3-none-any.whl

cordscript/functions/database/database.py

@@ -0,0 +1,846 @@
+from __future__ import annotations
+from .store import Database
+import sys
+import os
+from contextlib import redirect_stdout, redirect_stderr
+
+class SuppressOutput:
+    def __enter__(self):
+        self._stdout = sys.stdout
+        self._stderr = sys.stderr
+        sys.stdout = open(os.devnull, 'w')
+        sys.stderr = open(os.devnull, 'w')
+        return self
+
+    def __exit__(self, *args):
+        sys.stdout.close()
+        sys.stderr.close()
+        sys.stdout = self._stdout
+        sys.stderr = self._stderr
+
+def _detect_db(db) -> str:
+    t = type(db).__name__.lower()
+    module = type(db).__module__.lower()
+    if "motor" in module or "asynciomotorclient" in t:
+        return "motor"
+    if "mongoclient" in t or "mongo" in module:
+        return "pymongo"
+    if "asyncpg" in module:
+        return "asyncpg"
+    if "psycopg" in module:
+        return "psycopg"
+    if "bettersqlite" in t or "better_sqlite3" in module:
+        return "better_sqlite3"
+    if "connection" in t and "sqlite" in module:
+        return "sqlite3"
+    return "unknown"
+
+async def _init_table(db):
+    kind = _detect_db(db)
+    sql = """
+        CREATE TABLE IF NOT EXISTS cordscript_vars (
+            user_id TEXT,
+            key TEXT,
+            value TEXT,
+            PRIMARY KEY (user_id, key)
+        )
+    """
+    if kind == "motor":
+        await db["cordscript_vars"].create_index([("user_id", 1), ("key", 1)], unique=True)
+    elif kind in ("asyncpg", "psycopg"):
+        await db.execute(sql)
+    elif kind == "sqlite3":
+        cur = db.cursor()
+        cur.execute(sql)
+        db.commit()
+    elif kind == "better_sqlite3":
+        db.prepare(sql).run()
+
+async def connect_from_url(url: str):
+    if url.startswith("mongodb"):
+        try:
+            import motor.motor_asyncio
+            client = motor.motor_asyncio.AsyncIOMotorClient(url)
+            return client.get_default_database() or client["cordscript"]
+        except ImportError:
+            raise ImportError("motor not installed: pip install motor")
+    if url.startswith("postgresql") or url.startswith("postgres"):
+        try:
+            import asyncpg
+            return await asyncpg.connect(url)
+        except ImportError:
+            raise ImportError("asyncpg not installed: pip install asyncpg")
+    if url.startswith("sqlite"):
+        path = url.replace("sqlite:///", "").replace("sqlite://", "")
+        import sqlite3
+        return sqlite3.connect(path)
+    raise ValueError(f"Unrecognized database URL: {url}")
+
+async def _get_legacy(db, key: str, user_id: str) -> str:
+    kind = _detect_db(db)
+    try:
+        if kind == "motor":
+            doc = await db["cordscript_vars"].find_one({"user_id": user_id, "key": key})
+            return str(doc["value"]) if doc else ""
+        if kind == "pymongo":
+            doc = db["cordscript_vars"].find_one({"user_id": user_id, "key": key})
+            return str(doc["value"]) if doc else ""
+        if kind in ("asyncpg", "psycopg"):
+            row = await db.fetchrow("SELECT value FROM cordscript_vars WHERE user_id=$1 AND key=$2", user_id, key)
+            return str(row["value"]) if row else ""
+        if kind == "sqlite3":
+            cur = db.cursor()
+            cur.execute("SELECT value FROM cordscript_vars WHERE user_id=? AND key=?", (user_id, key))
+            row = cur.fetchone()
+            return str(row[0]) if row else ""
+        if kind == "better_sqlite3":
+            row = db.prepare("SELECT value FROM cordscript_vars WHERE user_id=? AND key=?").get(user_id, key)
+            return str(row["value"]) if row else ""
+    except Exception as e:
+        return f"[Error in $getVar: {e}]"
+    return ""
+
+async def _set_legacy(db, key: str, value: str, user_id: str):
+    kind = _detect_db(db)
+    try:
+        if kind == "motor":
+            await db["cordscript_vars"].update_one(
+                {"user_id": user_id, "key": key}, {"$set": {"value": value}}, upsert=True
+            )
+        elif kind == "pymongo":
+            db["cordscript_vars"].update_one(
+                {"user_id": user_id, "key": key}, {"$set": {"value": value}}, upsert=True
+            )
+        elif kind in ("asyncpg", "psycopg"):
+            await db.execute("""
+                INSERT INTO cordscript_vars (user_id, key, value)
+                VALUES ($1, $2, $3)
+                ON CONFLICT (user_id, key) DO UPDATE SET value=$3
+            """, user_id, key, value)
+        elif kind == "sqlite3":
+            cur = db.cursor()
+            cur.execute("""
+                INSERT INTO cordscript_vars (user_id, key, value)
+                VALUES (?, ?, ?)
+                ON CONFLICT(user_id, key) DO UPDATE SET value=excluded.value
+            """, (user_id, key, value))
+            db.commit()
+        elif kind == "better_sqlite3":
+            db.prepare("""
+                INSERT INTO cordscript_vars (user_id, key, value)
+                VALUES (?, ?, ?)
+                ON CONFLICT(user_id, key) DO UPDATE SET value=excluded.value
+            """).run(user_id, key, value)
+    except Exception as e:
+        return f"[Error in $setVar: {e}]"
+
+def _default_ids(ctx):
+    import discord
+    user_id = str(ctx.user.id) if isinstance(ctx, discord.Interaction) else str(getattr(ctx, "author", ctx).id)
+    channel = getattr(ctx, "channel", None)
+    channel_id = str(channel.id) if channel else ""
+    guild = getattr(ctx, "guild", None)
+    guild_id = str(guild.id) if guild else ""
+    return user_id, channel_id, guild_id
+
+async def handle_database(fn: str, args: list[str], raw: str, parser) -> str | None:
+    db = getattr(parser.client, "_database", None)
+    if db is None:
+        return None
+
+    ctx = parser.ctx
+    default_uid, default_cid, default_gid = _default_ids(ctx)
+
+    def _val(index: int) -> str:
+        return args[index] if len(args) > index else ""
+
+    def _key(index: int = 0) -> str:
+        return _val(index).strip()
+
+    try:
+        if isinstance(db, Database):
+            match fn:
+                case "getuservar":
+                    key = _key(0)
+                    uid = _val(1).strip() or default_uid
+                    if not key:
+                        return "[Error in $getUserVar: variable name required]"
+                    return db.get("user", uid, key)
+
+                case "setuservar":
+                    key = _key(0)
+                    value = _val(1)
+                    uid = _val(2).strip() or default_uid
+                    if not key:
+                        return "[Error in $setUserVar: variable name required]"
+                    db.set("user", uid, key, value)
+                    return ""
+
+                case "getchannelvar":
+                    key = _key(0)
+                    cid = _val(1).strip() or default_cid
+                    if not key:
+                        return "[Error in $getChannelVar: variable name required]"
+                    return db.get("channel", cid, key)
+
+                case "setchannelvar":
+                    key = _key(0)
+                    value = _val(1)
+                    cid = _val(2).strip() or default_cid
+                    if not key:
+                        return "[Error in $setChannelVar: variable name required]"
+                    db.set("channel", cid, key, value)
+                    return ""
+
+                case "getguildvar":
+                    key = _key(0)
+                    gid = _val(1).strip() or default_gid
+                    if not key:
+                        return "[Error in $getGuildVar: variable name required]"
+                    return db.get("guild", gid, key)
+
+                case "setguildvar":
+                    key = _key(0)
+                    value = _val(1)
+                    gid = _val(2).strip() or default_gid
+                    if not key:
+                        return "[Error in $setGuildVar: variable name required]"
+                    db.set("guild", gid, key, value)
+                    return ""
+
+                case "getvar":
+                    key = _key(0)
+                    uid = _val(1).strip() or default_uid
+                    if not key:
+                        return "[Error in $getVar: variable name required]"
+                    return db.get("user", uid, key)
+
+                case "setvar":
+                    key = _key(0)
+                    value = _val(1)
+                    uid = _val(2).strip() or default_uid
+                    if not key:
+                        return "[Error in $setVar: variable name required]"
+                    db.set("user", uid, key, value)
+                    return ""
+
+                case "getdb":
+                    import json
+                    try:
+                        with SuppressOutput():
+                            all_data = db.get_all() if hasattr(db, 'get_all') else {}
+                        return json.dumps(all_data, indent=2, ensure_ascii=False)
+                    except Exception as e:
+                        return f"[Error in $getDB: {e}]"
+
+                case "searchdb":
+                    import json
+                    try:
+                        path = _key(0)
+                        with SuppressOutput():
+                            all_data = db.get_all() if hasattr(db, 'get_all') else {}
+
+                        if not path:
+                            return json.dumps(all_data, indent=2, ensure_ascii=False)
+
+                        results = {}
+                        def search_recursive(obj, search_term, current_path=""):
+                            if isinstance(obj, dict):
+                                for key, value in obj.items():
+                                    new_path = f"{current_path}.{key}" if current_path else key
+                                    if search_term.lower() in key.lower():
+                                        results[new_path] = value
+                                    search_recursive(value, search_term, new_path)
+                            elif isinstance(obj, list):
+                                for i, item in enumerate(obj):
+                                    new_path = f"{current_path}[{i}]"
+                                    search_recursive(item, search_term, new_path)
+                            elif isinstance(obj, str) and search_term.lower() in obj.lower():
+                                results[current_path] = obj
+
+                        search_recursive(all_data, path)
+
+                        if results:
+                            return json.dumps(results, indent=2, ensure_ascii=False)
+                        else:
+                            return f"[No results found for '{path}']"
+                    except Exception as e:
+                        return f"[Error in $searchDB: {e}]"
+
+                case "wipedb":
+                    try:
+                        with SuppressOutput():
+                            if hasattr(db, 'wipe'):
+                                db.wipe()
+                                return "[Database wiped successfully]"
+                            else:
+                                return "[Error in $wipeDB: wipe method not available]"
+                    except Exception as e:
+                        return f"[Error in $wipeDB: {e}]"
+
+                case "getuserleaderboardid":
+                    name = _key(0)
+                    sort_type = _key(1) or "DESC"
+                    position = int(_key(2)) if _key(2) else 1
+
+                    if not name:
+                        return "[Error in $getUserLeaderboardID: name required]"
+
+                    try:
+                        with SuppressOutput():
+                            all_data = db.get_all() if hasattr(db, 'get_all') else {}
+
+                        leaderboard = {}
+                        if "user" in all_data:
+                            for user_id, vars_dict in all_data.get("user", {}).items():
+                                if name in vars_dict:
+                                    try:
+                                        value = float(vars_dict[name])
+                                        leaderboard[user_id] = value
+                                    except (ValueError, TypeError):
+                                        pass
+
+                        if sort_type.upper() == "ASC":
+                            sorted_lb = sorted(leaderboard.items(), key=lambda x: x[1])
+                        else:
+                            sorted_lb = sorted(leaderboard.items(), key=lambda x: x[1], reverse=True)
+
+                        if 1 <= position <= len(sorted_lb):
+                            return sorted_lb[position - 1][0]
+                        else:
+                            return "[Position not found]"
+                    except Exception as e:
+                        return f"[Error in $getUserLeaderboardID: {e}]"
+
+                case "userleaderboard":
+                    name = _key(0)
+                    sort_type = _key(1) or "DESC"
+                    max_items = int(_key(2)) if _key(2) else 10
+                    page = int(_key(3)) if _key(3) else 1
+                    separator = _val(4) or "\n"
+                    env_value = _key(5) or "{value}"
+                    env_position = _key(6) or "{position}"
+                    code = _val(7) or "{position}. {user_id} - {value}"
+
+                    if not name:
+                        return "[Error in $userLeaderboard: name required]"
+
+                    try:
+                        with SuppressOutput():
+                            all_data = db.get_all() if hasattr(db, 'get_all') else {}
+
+                        leaderboard = {}
+                        if "user" in all_data:
+                            for user_id, vars_dict in all_data.get("user", {}).items():
+                                if name in vars_dict:
+                                    try:
+                                        value = float(vars_dict[name])
+                                        leaderboard[user_id] = value
+                                    except (ValueError, TypeError):
+                                        pass
+
+                        if sort_type.upper() == "ASC":
+                            sorted_lb = sorted(leaderboard.items(), key=lambda x: x[1])
+                        else:
+                            sorted_lb = sorted(leaderboard.items(), key=lambda x: x[1], reverse=True)
+
+                        start = (page - 1) * max_items
+                        end = start + max_items
+                        page_data = sorted_lb[start:end]
+
+                        if not page_data:
+                            return "[No data for this page]"
+
+                        result = []
+                        for pos, (user_id, value) in enumerate(page_data, start=start + 1):
+                            line = code.replace(env_value, str(value))
+                            line = line.replace(env_position, str(pos))
+                            line = line.replace("{user_id}", user_id)
+                            line = line.replace("{value}", str(value))
+                            line = line.replace("{position}", str(pos))
+                            result.append(line)
+
+                        return separator.join(result)
+                    except Exception as e:
+                        return f"[Error in $userLeaderboard: {e}]"
+
+                case "getuserleaderboardlength":
+                    name = _key(0)
+                    length_type = _key(1) or "count"
+                    decimals = int(_key(2)) if _key(2) else 0
+
+                    if not name:
+                        return "[Error in $getUserLeaderboardLength: name required]"
+
+                    try:
+                        with SuppressOutput():
+                            all_data = db.get_all() if hasattr(db, 'get_all') else {}
+
+                        values = []
+                        if "user" in all_data:
+                            for user_id, vars_dict in all_data.get("user", {}).items():
+                                if name in vars_dict:
+                                    try:
+                                        value = float(vars_dict[name])
+                                        values.append(value)
+                                    except (ValueError, TypeError):
+                                        pass
+
+                        if length_type.lower() == "count":
+                            result = len(values)
+                        elif length_type.lower() == "sum":
+                            result = sum(values) if values else 0
+                        elif length_type.lower() == "avg":
+                            result = sum(values) / len(values) if values else 0
+                        elif length_type.lower() == "max":
+                            result = max(values) if values else 0
+                        elif length_type.lower() == "min":
+                            result = min(values) if values else 0
+                        else:
+                            result = len(values)
+
+                        if decimals > 0:
+                            result = round(result, decimals)
+                        else:
+                            result = int(result)
+
+                        return str(result)
+                    except Exception as e:
+                        return f"[Error in $getUserLeaderboardLength: {e}]"
+
+                case "getuserleaderboardvalue":
+                    name = _key(0)
+                    sort_type = _key(1) or "DESC"
+                    user_id = _key(2)
+
+                    if not name:
+                        return "[Error in $getUserLeaderboardValue: name required]"
+
+                    if not user_id:
+                        import discord
+                        ctx = parser.ctx
+                        user_id = str(ctx.user.id) if isinstance(ctx, discord.Interaction) else str(getattr(ctx, "author", ctx).id)
+
+                    try:
+                        with SuppressOutput():
+                            all_data = db.get_all() if hasattr(db, 'get_all') else {}
+
+                        leaderboard = {}
+                        if "user" in all_data:
+                            for uid, vars_dict in all_data.get("user", {}).items():
+                                if name in vars_dict:
+                                    try:
+                                        value = float(vars_dict[name])
+                                        leaderboard[uid] = value
+                                    except (ValueError, TypeError):
+                                        pass
+
+                        if str(user_id) not in leaderboard:
+                            return "[User not in leaderboard]"
+
+                        user_value = leaderboard[str(user_id)]
+
+                        if sort_type.upper() == "ASC":
+                            sorted_lb = sorted(leaderboard.items(), key=lambda x: x[1])
+                        else:
+                            sorted_lb = sorted(leaderboard.items(), key=lambda x: x[1], reverse=True)
+
+                        position = next((i + 1 for i, (uid, _) in enumerate(sorted_lb) if uid == str(user_id)), None)
+
+                        return f"{user_value}|{position}"
+                    except Exception as e:
+                        return f"[Error in $getUserLeaderboardValue: {e}]"
+
+                case _:
+                    return None
+
+        match fn:
+            case "setvar":
+                key = _key(0)
+                value = _val(1)
+                uid = _val(2).strip() or default_uid
+                if not key:
+                    return "[Error in $setVar: variable name required]"
+                result = await _set_legacy(db, key, value, uid)
+                return result or ""
+
+            case "getvar":
+                key = _key(0)
+                uid = _val(1).strip() or default_uid
+                if not key:
+                    return "[Error in $getVar: variable name required]"
+                return await _get_legacy(db, key, uid)
+
+            case "getdb":
+                import json
+                try:
+                    kind = _detect_db(db)
+                    all_data = {}
+
+                    with SuppressOutput():
+                        if kind == "motor":
+                            cursor = db["cordscript_vars"].find({})
+                            async for doc in cursor:
+                                doc.pop("_id", None)
+                                all_data[f"{doc['user_id']}_{doc['key']}"] = doc['value']
+                        elif kind == "pymongo":
+                            for doc in db["cordscript_vars"].find({}):
+                                doc.pop("_id", None)
+                                all_data[f"{doc['user_id']}_{doc['key']}"] = doc['value']
+                        elif kind in ("asyncpg", "psycopg"):
+                            rows = await db.fetch("SELECT * FROM cordscript_vars")
+                            for row in rows:
+                                all_data[f"{row['user_id']}_{row['key']}"] = row['value']
+                        elif kind == "sqlite3":
+                            cur = db.cursor()
+                            cur.execute("SELECT * FROM cordscript_vars")
+                            for row in cur.fetchall():
+                                all_data[f"{row[0]}_{row[1]}"] = row[2]
+                        elif kind == "better_sqlite3":
+                            rows = db.prepare("SELECT * FROM cordscript_vars").all()
+                            for row in rows:
+                                all_data[f"{row['user_id']}_{row['key']}"] = row['value']
+
+                    return json.dumps(all_data, indent=2, ensure_ascii=False)
+                except Exception as e:
+                    return f"[Error in $getDB: {e}]"
+
+            case "searchdb":
+                import json
+                try:
+                    path = _key(0)
+                    kind = _detect_db(db)
+                    all_data = {}
+
+                    with SuppressOutput():
+                        if kind == "motor":
+                            cursor = db["cordscript_vars"].find({})
+                            async for doc in cursor:
+                                doc.pop("_id", None)
+                                all_data[f"{doc['user_id']}_{doc['key']}"] = doc['value']
+                        elif kind == "pymongo":
+                            for doc in db["cordscript_vars"].find({}):
+                                doc.pop("_id", None)
+                                all_data[f"{doc['user_id']}_{doc['key']}"] = doc['value']
+                        elif kind in ("asyncpg", "psycopg"):
+                            rows = await db.fetch("SELECT * FROM cordscript_vars")
+                            for row in rows:
+                                all_data[f"{row['user_id']}_{row['key']}"] = row['value']
+                        elif kind == "sqlite3":
+                            cur = db.cursor()
+                            cur.execute("SELECT * FROM cordscript_vars")
+                            for row in cur.fetchall():
+                                all_data[f"{row[0]}_{row[1]}"] = row[2]
+                        elif kind == "better_sqlite3":
+                            rows = db.prepare("SELECT * FROM cordscript_vars").all()
+                            for row in rows:
+                                all_data[f"{row['user_id']}_{row['key']}"] = row['value']
+
+                    if not path:
+                        return json.dumps(all_data, indent=2, ensure_ascii=False)
+
+                    results = {}
+                    for key, value in all_data.items():
+                        if path.lower() in key.lower() or path.lower() in str(value).lower():
+                            results[key] = value
+
+                    if results:
+                        return json.dumps(results, indent=2, ensure_ascii=False)
+                    else:
+                        return f"[No results found for '{path}']"
+                except Exception as e:
+                    return f"[Error in $searchDB: {e}]"
+
+            case "wipedb":
+                try:
+                    kind = _detect_db(db)
+                    with SuppressOutput():
+                        if kind == "motor":
+                            await db["cordscript_vars"].delete_many({})
+                        elif kind == "pymongo":
+                            db["cordscript_vars"].delete_many({})
+                        elif kind in ("asyncpg", "psycopg"):
+                            await db.execute("DELETE FROM cordscript_vars")
+                        elif kind == "sqlite3":
+                            cur = db.cursor()
+                            cur.execute("DELETE FROM cordscript_vars")
+                            db.commit()
+                        elif kind == "better_sqlite3":
+                            db.prepare("DELETE FROM cordscript_vars").run()
+                    return "[Database wiped successfully]"
+                except Exception as e:
+                    return f"[Error in $wipeDB: {e}]"
+
+            case "getuserleaderboardid":
+                name = _key(0)
+                sort_type = _key(1) or "DESC"
+                position = int(_key(2)) if _key(2) else 1
+
+                if not name:
+                    return "[Error in $getUserLeaderboardID: name required]"
+
+                try:
+                    kind = _detect_db(db)
+                    all_data = {}
+
+                    with SuppressOutput():
+                        if kind == "motor":
+                            cursor = db["cordscript_vars"].find({})
+                            async for doc in cursor:
+                                doc.pop("_id", None)
+                                all_data[f"{doc['user_id']}_{doc['key']}"] = doc['value']
+                        elif kind == "pymongo":
+                            for doc in db["cordscript_vars"].find({}):
+                                doc.pop("_id", None)
+                                all_data[f"{doc['user_id']}_{doc['key']}"] = doc['value']
+                        elif kind in ("asyncpg", "psycopg"):
+                            rows = await db.fetch("SELECT * FROM cordscript_vars")
+                            for row in rows:
+                                all_data[f"{row['user_id']}_{row['key']}"] = row['value']
+                        elif kind == "sqlite3":
+                            cur = db.cursor()
+                            cur.execute("SELECT * FROM cordscript_vars")
+                            for row in cur.fetchall():
+                                all_data[f"{row[0]}_{row[1]}"] = row[2]
+                        elif kind == "better_sqlite3":
+                            rows = db.prepare("SELECT * FROM cordscript_vars").all()
+                            for row in rows:
+                                all_data[f"{row['user_id']}_{row['key']}"] = row['value']
+
+                    leaderboard = {}
+                    for key, value in all_data.items():
+                        if f"_{name}" in key:
+                            user_id = key.split("_")[0]
+                            try:
+                                val = float(value)
+                                leaderboard[user_id] = val
+                            except (ValueError, TypeError):
+                                pass
+
+                    if sort_type.upper() == "ASC":
+                        sorted_lb = sorted(leaderboard.items(), key=lambda x: x[1])
+                    else:
+                        sorted_lb = sorted(leaderboard.items(), key=lambda x: x[1], reverse=True)
+
+                    if 1 <= position <= len(sorted_lb):
+                        return sorted_lb[position - 1][0]
+                    else:
+                        return "[Position not found]"
+                except Exception as e:
+                    return f"[Error in $getUserLeaderboardID: {e}]"
+
+            case "userleaderboard":
+                name = _key(0)
+                sort_type = _key(1) or "DESC"
+                max_items = int(_key(2)) if _key(2) else 10
+                page = int(_key(3)) if _key(3) else 1
+                separator = _val(4) or "\n"
+                env_value = _key(5) or "{value}"
+                env_position = _key(6) or "{position}"
+                code = _val(7) or "{position}. {user_id} - {value}"
+
+                if not name:
+                    return "[Error in $userLeaderboard: name required]"
+
+                try:
+                    kind = _detect_db(db)
+                    all_data = {}
+
+                    with SuppressOutput():
+                        if kind == "motor":
+                            cursor = db["cordscript_vars"].find({})
+                            async for doc in cursor:
+                                doc.pop("_id", None)
+                                all_data[f"{doc['user_id']}_{doc['key']}"] = doc['value']
+                        elif kind == "pymongo":
+                            for doc in db["cordscript_vars"].find({}):
+                                doc.pop("_id", None)
+                                all_data[f"{doc['user_id']}_{doc['key']}"] = doc['value']
+                        elif kind in ("asyncpg", "psycopg"):
+                            rows = await db.fetch("SELECT * FROM cordscript_vars")
+                            for row in rows:
+                                all_data[f"{row['user_id']}_{row['key']}"] = row['value']
+                        elif kind == "sqlite3":
+                            cur = db.cursor()
+                            cur.execute("SELECT * FROM cordscript_vars")
+                            for row in cur.fetchall():
+                                all_data[f"{row[0]}_{row[1]}"] = row[2]
+                        elif kind == "better_sqlite3":
+                            rows = db.prepare("SELECT * FROM cordscript_vars").all()
+                            for row in rows:
+                                all_data[f"{row['user_id']}_{row['key']}"] = row['value']
+
+                    leaderboard = {}
+                    for key, value in all_data.items():
+                        if f"_{name}" in key:
+                            user_id = key.split("_")[0]
+                            try:
+                                val = float(value)
+                                leaderboard[user_id] = val
+                            except (ValueError, TypeError):
+                                pass
+
+                    if sort_type.upper() == "ASC":
+                        sorted_lb = sorted(leaderboard.items(), key=lambda x: x[1])
+                    else:
+                        sorted_lb = sorted(leaderboard.items(), key=lambda x: x[1], reverse=True)
+
+                    start = (page - 1) * max_items
+                    end = start + max_items
+                    page_data = sorted_lb[start:end]
+
+                    if not page_data:
+                        return "[No data for this page]"
+
+                    result = []
+                    for pos, (user_id, value) in enumerate(page_data, start=start + 1):
+                        line = code.replace(env_value, str(value))
+                        line = line.replace(env_position, str(pos))
+                        line = line.replace("{user_id}", user_id)
+                        line = line.replace("{value}", str(value))
+                        line = line.replace("{position}", str(pos))
+                        result.append(line)
+
+                    return separator.join(result)
+                except Exception as e:
+                    return f"[Error in $userLeaderboard: {e}]"
+
+            case "getuserleaderboardlength":
+                name = _key(0)
+                length_type = _key(1) or "count"
+                decimals = int(_key(2)) if _key(2) else 0
+
+                if not name:
+                    return "[Error in $getUserLeaderboardLength: name required]"
+
+                try:
+                    kind = _detect_db(db)
+                    all_data = {}
+
+                    with SuppressOutput():
+                        if kind == "motor":
+                            cursor = db["cordscript_vars"].find({})
+                            async for doc in cursor:
+                                doc.pop("_id", None)
+                                all_data[f"{doc['user_id']}_{doc['key']}"] = doc['value']
+                        elif kind == "pymongo":
+                            for doc in db["cordscript_vars"].find({}):
+                                doc.pop("_id", None)
+                                all_data[f"{doc['user_id']}_{doc['key']}"] = doc['value']
+                        elif kind in ("asyncpg", "psycopg"):
+                            rows = await db.fetch("SELECT * FROM cordscript_vars")
+                            for row in rows:
+                                all_data[f"{row['user_id']}_{row['key']}"] = row['value']
+                        elif kind == "sqlite3":
+                            cur = db.cursor()
+                            cur.execute("SELECT * FROM cordscript_vars")
+                            for row in cur.fetchall():
+                                all_data[f"{row[0]}_{row[1]}"] = row[2]
+                        elif kind == "better_sqlite3":
+                            rows = db.prepare("SELECT * FROM cordscript_vars").all()
+                            for row in rows:
+                                all_data[f"{row['user_id']}_{row['key']}"] = row['value']
+
+                    values = []
+                    for key, value in all_data.items():
+                        if f"_{name}" in key:
+                            try:
+                                val = float(value)
+                                values.append(val)
+                            except (ValueError, TypeError):
+                                pass
+
+                    if length_type.lower() == "count":
+                        result = len(values)
+                    elif length_type.lower() == "sum":
+                        result = sum(values) if values else 0
+                    elif length_type.lower() == "avg":
+                        result = sum(values) / len(values) if values else 0
+                    elif length_type.lower() == "max":
+                        result = max(values) if values else 0
+                    elif length_type.lower() == "min":
+                        result = min(values) if values else 0
+                    else:
+                        result = len(values)
+
+                    if decimals > 0:
+                        result = round(result, decimals)
+                    else:
+                        result = int(result)
+
+                    return str(result)
+                except Exception as e:
+                    return f"[Error in $getUserLeaderboardLength: {e}]"
+
+            case "getuserleaderboardvalue":
+                name = _key(0)
+                sort_type = _key(1) or "DESC"
+                user_id = _key(2)
+
+                if not name:
+                    return "[Error in $getUserLeaderboardValue: name required]"
+
+                if not user_id:
+                    import discord
+                    ctx = parser.ctx
+                    user_id = str(ctx.user.id) if isinstance(ctx, discord.Interaction) else str(getattr(ctx, "author", ctx).id)
+
+                try:
+                    kind = _detect_db(db)
+                    all_data = {}
+
+                    with SuppressOutput():
+                        if kind == "motor":
+                            cursor = db["cordscript_vars"].find({})
+                            async for doc in cursor:
+                                doc.pop("_id", None)
+                                all_data[f"{doc['user_id']}_{doc['key']}"] = doc['value']
+                        elif kind == "pymongo":
+                            for doc in db["cordscript_vars"].find({}):
+                                doc.pop("_id", None)
+                                all_data[f"{doc['user_id']}_{doc['key']}"] = doc['value']
+                        elif kind in ("asyncpg", "psycopg"):
+                            rows = await db.fetch("SELECT * FROM cordscript_vars")
+                            for row in rows:
+                                all_data[f"{row['user_id']}_{row['key']}"] = row['value']
+                        elif kind == "sqlite3":
+                            cur = db.cursor()
+                            cur.execute("SELECT * FROM cordscript_vars")
+                            for row in cur.fetchall():
+                                all_data[f"{row[0]}_{row[1]}"] = row[2]
+                        elif kind == "better_sqlite3":
+                            rows = db.prepare("SELECT * FROM cordscript_vars").all()
+                            for row in rows:
+                                all_data[f"{row['user_id']}_{row['key']}"] = row['value']
+
+                    leaderboard = {}
+                    for key, value in all_data.items():
+                        if f"_{name}" in key:
+                            uid = key.split("_")[0]
+                            try:
+                                val = float(value)
+                                leaderboard[uid] = val
+                            except (ValueError, TypeError):
+                                pass
+
+                    if str(user_id) not in leaderboard:
+                        return "[User not in leaderboard]"
+
+                    user_value = leaderboard[str(user_id)]
+
+                    if sort_type.upper() == "ASC":
+                        sorted_lb = sorted(leaderboard.items(), key=lambda x: x[1])
+                    else:
+                        sorted_lb = sorted(leaderboard.items(), key=lambda x: x[1], reverse=True)
+
+                    position = next((i + 1 for i, (uid, _) in enumerate(sorted_lb) if uid == str(user_id)), None)
+
+                    return f"{user_value}|{position}"
+                except Exception as e:
+                    return f"[Error in $getUserLeaderboardValue: {e}]"
+
+            case _:
+                return None
+
+    except Exception as e:
+        return f"[Unexpected error in ${fn}: {e}]"