रेडिस सॉर्टेड सेट के साथ इंटेलिजेंट स्वत:पूर्ण बनाएं

स्मार्ट ऑटोकम्प्लीट सिस्टम का विचार

यह खोज अनुप्रयोगों के लिए क्यों महत्वपूर्ण है

• "इंटरसेप्टर"
• "अंतरराज्यीय 60"
• "इंटरस्टेलर"

• स्ट्रीमिंग सेवाएं नेटफ्लिक्स या यूट्यूब की तरह यह दिखाने के लिए कि लोग सबसे ज्यादा क्या देख रहे हैं
• ऑनलाइन स्टोर खोजते समय सबसे पहले लोकप्रिय उत्पाद दिखाएं
• सहायता केंद्र लोगों द्वारा पूछे जाने वाले सबसे सामान्य प्रश्न दिखाने के लिए
• खोज वाली कोई भी वेबसाइट यह दिखाने के लिए कि अधिकांश लोग पहले किस पर क्लिक करते हैं

रेडिस सॉर्टेड सेट को समझना

• प्रत्येक आइटम अद्वितीय है (एक सेट की तरह)
• प्रत्येक आइटम का एक स्कोर होता है (ऑर्डर करने के लिए)
• आइटम को उनके स्कोर के आधार पर तुरंत क्रमबद्ध किया जा सकता है

1. पाठ उपसर्गों के मिलान के लिए एक (उदाहरण के लिए "int" "इंटरस्टेलर" से मेल खाता है)
2. प्रत्येक सुझाव कितना लोकप्रिय है, इस पर नज़र रखने के लिए एक और

आधार:वर्णमाला क्रम

1. सभी उपसर्गों को संग्रहीत करें एकल डेटा संरचना में खोजने योग्य शब्द
2. ZRANK का उपयोग करें O(log N) समय में किसी भी उपसर्ग की प्रारंभिक स्थिति ज्ञात करने के लिए
3. ZSCAN का उपयोग करें उस स्थिति से शुरू होने वाले सभी मैचों को कुशलतापूर्वक पुनः प्राप्त करने के लिए
4. ZMSCORE का उपयोग करें प्रत्येक मैच का लोकप्रियता स्कोर प्राप्त करने के लिए
5. ZINCRBY का उपयोग करें प्रत्येक मैच का लोकप्रियता स्कोर बढ़ाने के लिए

• स्कोर:0, सदस्य:"मैं"
• स्कोर:0, सदस्य:"IN"
• स्कोर:0, सदस्य:"INT"
• स्कोर:0, सदस्य:"INTE"
• स्कोर:0, सदस्य:"इंटर"
• स्कोर:0, सदस्य:"इंटरस्टेलर$इंटरस्टेलर" (प्रदर्शन प्रारूप के साथ पूर्ण प्रविष्टि)

हम डेटा कैसे संग्रहीत करते हैं

1. मूवी शीर्षक सूची

2. लोकप्रिय फ़िल्मों की सूची

एल्गोरिदमिक प्रवाह

graph TD
 A[User types 'int'] --> B[ZRANK: Find lexicographic position of 'INT']
 B --> C[ZSCAN: Retrieve matches starting from position (movies set)]
 C --> D[Filter: Extract complete terms containing '$']
 D --> E[ZMSCORE: Get popularity scores for all matches (movie-popularity set)]
 E --> F[Rank: Return highest-scored suggestion]
 G[User selects suggestion] --> H[ZINCRBY: Increment popularity score]
 H --> I[Future searches: Higher scored items rank first]
 I --> A

आइए स्वत:पूर्ण सिस्टम बनाएं

चरण 1:Redis में मूवी शीर्षक जोड़ना

import { Redis } from "@upstash/redis";
 
const redis = new Redis({
 url: process.env.UPSTASH_REDIS_URL!,
 token: process.env.UPSTASH_REDIS_TOKEN!,
});
 
// Example: your list of titles
const titles = [
 "Interceptor",
 "Interstate 60",
 "Interstellar",
 // ... more titles
];
 
async function populateAutocomplete() {
 // Insert prefixes and full titles into the 'movies' sorted set
 for (const title of titles) {
 let term = title.toUpperCase();
 let terms = [];
 for (let i = 1; i < term.length; i++) {
 terms.push({ score: 0, member: term.substring(0, i) });
 }
 terms.push({ score: 0, member: term });
 terms.push({ score: 0, member: term + "$" + title });
 await redis.zadd("movies", ...terms);
 }
 
 // Insert all titles into the 'movie-popularity' sorted set for popularity tracking
 await redis.zadd(
 "movie-popularity",
 ...titles.map((title) => ({
 score: 0,
 member: title.toUpperCase(),
 })),
 );
}
 
populateAutocomplete();

1. <पी> प्रत्येक फिल्म के शीर्षक के लिए, हम संग्रहित करते हैं:
   • सभी संभावित आंशिक मिलान (जैसे "INT", "INTE", "इंटर" के लिए "इंटरस्टेलर")
   • पूरा शीर्षक ही
   • प्रदर्शन के लिए एक स्वरूपित संस्करण
2. <पी> हम एक अलग सूची भी बनाते हैं जो ट्रैक करती है कि प्रत्येक फिल्म कितनी लोकप्रिय है, शून्य दृश्य से शुरू होकर

चरण 2:सर्वोत्तम मिलान ढूँढना

export const matchQuery = async (query: string): Promise<string | null> => {
 const upperQuery = query.toUpperCase();
 
 // Step 1: Find starting position using lexicographic ordering
 let rank = await redis.zrank("movies", upperQuery);
 if (rank === null) return null;
 
 // Step 2: Efficiently scan for matches from that position
 const scanResult = await redis.zscan("movies", rank, {
 match: `${upperQuery}*$*`,
 count: 1000,
 });
 
 // Step 3: Extract complete entries and get their popularity scores
 const completeTitles = scanResult[1].filter(
 (el, idx) => idx % 2 === 0 && el.includes("$"),
 );
 
 const baseNames = completeTitles.map((title) => title.split("$")[0]);
 const scores = await redis.zmscore("movie-popularity", baseNames);
 
 // Step 4: Return the highest-scored (most popular) match
 const maxScore = Math.max(...scores);
 const bestMatchIndex = scores.indexOf(maxScore);
 return completeTitles[bestMatchIndex].split("$")[1];
};

उपयोगकर्ता की पसंद से सीखना

const onSubmit = async (title: string) => {
 // Handle submit logic here
 await redis.zincrby("movie-popularity", 1, title.toUpperCase());
};

यह कितना तेज़ है?

• ZRANK :O(लॉग एन) - लॉगरिदमिक लुकअप समय
• ZSCAN :O(लॉग एन + एम) - जहां एम लौटाए गए तत्वों की संख्या है
• ZMSCORE :O(N) - जहां N मिलान किए गए परिणामों की संख्या है, न कि कुल डेटासेट आकार
• ZINCRBY :O(लॉग एन) - लघुगणकीय जटिलता के साथ परमाणु वृद्धि

निष्कर्ष:हमने मिलकर क्या बनाया