सोलर परिणामों में पहलू श्रेणियां कैसे प्राप्त करें?

Question

मान लें कि मेरे पास सोलर में दस्तावेज़ों के लिए मूल्य नामक फ़ील्ड है और मेरे पास फ़ील्ड पहलू है। मैं पहलुओं को मानों की श्रेणियों के रूप में प्राप्त करना चाहता हूं (उदाहरण: 0-100, 100-500, 500-1000, आदि)। यह कैसे करना है?

मैं पहले से श्रेणियों को निर्दिष्ट कर सकता हूं, लेकिन मैं यह भी जानना चाहता हूं कि दस्तावेजों में मूल्यों के आधार पर स्वचालित रूप से श्रेणियों की गणना करना संभव है (5 मानों के लिए कहें)?

Answer 1

एक बेहतर सौर-विशिष्ट उत्तर हो सकता है, लेकिन मैं सीधे लुसीन के साथ काम करता हूं, और चूंकि आपको ज्यादा कर्षण नहीं मिल रहा है, इसलिए मैं एक स्टैब ले जाऊंगा। वहां, मैं एक को FilteredQuery के साथ मूल Query लपेटकर एक जनसंख्या बनाउंगा। तो मुझे ब्याज के क्षेत्र के लिए FieldCache मिल जाएगा। फ़िल्टर के बिटसेट में हिट की गणना करें, और प्रत्येक हिट के लिए, आपको फील्ड कैश से फ़ील्ड का मान मिलता है, और इसे सॉर्टेडसेट में जोड़ें। जब आपको सभी हिट मिलती हैं, तो सेट के आकार को अपनी इच्छित श्रेणियों की संख्या में विभाजित करें (पांच से सात उपयोगकर्ता इंटरफ़ेस लोगों के अनुसार एक अच्छी संख्या है), और एक मूल्यवान बाधा के बजाय, आपके पहलू उन सबसेट्स में से प्रत्येक के निचले और ऊपरी सीमाओं के साथ एक श्रेणी क्वेरी हो।

मैं कुछ विशेष-मामला तर्कों का उपयोग करने की सलाह दूंगा; जाहिर है, यदि आपके पास केवल चार अलग-अलग मान हैं, तो उनमें से 5 रेंज परिशोधन करने की कोशिश करने और समझने में कोई अर्थ नहीं है। एक निश्चित दहलीज के नीचे (3 * श्रेणियों की अपनी आदर्श संख्या कहें), आप केवल श्रेणियों की बजाय सामान्य रूप से पहलू दिखाते हैं।

Answer 2

अपने पहले प्रश्न का उत्तर देने के लिए, आप सामान्य पहलू क्वेरी समर्थन का उपयोग करके पहलू श्रेणियां प्राप्त कर सकते हैं। Here के एक उदाहरण:

http://localhost:8983/solr/select?q=video&rows=0&facet=true&facet.query=price:[*+TO+500]&facet.query=price:[500+TO+*] 

अपने दूसरे प्रश्न का सवाल है (स्वतः पहलू पर्वतमाला का सुझाव दे), कि अभी तक लागू नहीं किया है। कुछ लोग तर्क देते हैं कि इस तरह की पूछताछ आपके आवेदन पर सबसे अच्छी तरह लागू की जाएगी बल्कि सौर "अनुमान" को सर्वोत्तम पहलू श्रेणियों को देने दें।

यहाँ विषय पर कुछ विचार-विमर्श कर रहे हैं:

• (संग्रहीत) https://web.archive.org/web/20100416235126/http://old.nabble.com/Re:-faceted-browsing-p3753053.html
• (संग्रहीत) https://web.archive.org/web/20090430160232/http://www.nabble.com/Re:-Sorting-p6803791.html
• (संग्रहीत) https://web.archive.org/web/20090504020754/http://www.nabble.com/Dynamically-calculated-range-facet-td11314725.html

Answer 3

आप Solr पहलू का उपयोग कर सकते सीमाओं

http://wiki.apache.org/solr/SimpleFacetParameters#Facet_by_Range

Answer 4

मैंने उत्पाद मूल्य सीमाओं के लिए समझदार गतिशील पहलुओं की गणना करने के तरीके का काम किया है। समाधान में दस्तावेज़ों के कुछ पूर्व प्रसंस्करण और क्वेरी परिणामों के कुछ पोस्ट-प्रोसेसिंग शामिल हैं, लेकिन इसे सोलर को केवल एक प्रश्न की आवश्यकता है, और 1.4 जैसे सौर के पुराने संस्करण पर भी काम करना चाहिए।

दौर ऊपर प्रस्तुत करने से पहले कीमतों

पहले, दस्तावेज़ प्रस्तुत करने से पहले, एक "rounded_price" क्षेत्र में दौर अप निकटतम "अच्छा दौर पहलू सीमा" के लिए कीमत और यह दुकान। उपयोगकर्ता अपने पहलुओं को "250-500" की तरह दिखने के लिए "247-483" नहीं दिखते हैं, और राउंडिंग का भी अर्थ है कि आप सैकड़ों मूल्य पहलुओं को वापस पा सकते हैं जिनमें से लाखों लोग नहीं हैं।, ..., 24,25,30,35, ..., 95.100.110

public static decimal RoundPrice(decimal price) 
    { 
     if (price < 25) 
      return Math.Ceiling(price); 
     else if (price < 100) 
      return Math.Ceiling(price/5) * 5; 
     else if (price < 250) 
      return Math.Ceiling(price/10) * 10; 
     else if (price < 1000) 
      return Math.Ceiling(price/25) * 25; 
     else if (price < 2500) 
      return Math.Ceiling(price/100) * 100; 
     else if (price < 10000) 
      return Math.Ceiling(price/250) * 250; 
     else if (price < 25000) 
      return Math.Ceiling(price/1000) * 1000; 
     else if (price < 100000) 
      return Math.Ceiling(price/2500) * 2500; 
     else 
      return Math.Ceiling(price/5000) * 5000; 
    } 

अनुमत कीमतों 1,2,3 जाना: कुछ प्रयास के साथ निम्नलिखित कोड किसी भी कीमत पैमाने पर अच्छी तरह से पूर्णांक बनाना सामान्यीकृत किया जा सकता , ..., 240,250,275,300,325, ..., 975,1000 और बहुत आगे। facet.field=rounded_price:

गोल कीमतों

दूसरा, जब क्वेरी प्रस्तुत करने, मूल्य के अनुसार क्रमबद्ध गोल की कीमतों पर सभी पहलुओं का अनुरोध पर सभी पहलुओं प्राप्त करें। गोल करने के लिए धन्यवाद, आपको कुछ सौ पहलू वापस मिलेंगे।

बड़ा पहलुओं

तीसरा में आसन्न पहलुओं कम्बाइन, आप परिणाम के बाद, उपयोगकर्ता केवल 3 से 7 पहलुओं, नहीं पहलुओं के सैकड़ों देखना चाहता है। तो, प्रत्येक खंड में लगभग बराबर संख्या में दस्तावेज़ प्राप्त करने की कोशिश कर रहे कुछ बड़े पहलुओं (जिसे "सेगमेंट" कहा जाता है) में आसन्न पहलुओं को गठबंधन करें। निम्न बल्कि जटिल कोड यह करता है, रेंज क्वेरी करने के लिए उपयुक्त (प्रारंभ, अंत, गिनती) के tuples लौट रहा है। मायने रखता है लौटे सही प्रदान किए गए मूल्यों हो जाएगा ऊपरगोल कर दिया गया निकटतम सीमा तक: चयनित पहलू

चौथा, मान लीजिए द्वारा

public static List<Tuple<string, string, int>> CombinePriceFacets(int nSegments, ICollection<KeyValuePair<string, int>> prices) 
    { 
     var ranges = new List<Tuple<string, string, int>>(); 
     int productCount = prices.Sum(p => p.Value); 
     int productsRemaining = productCount; 
     if (nSegments < 2) 
      return ranges; 
     int segmentSize = productCount/nSegments; 
     string start = "*"; 
     string end = "0"; 
     int count = 0; 
     int totalCount = 0; 
     int segmentIdx = 1; 
     foreach (KeyValuePair<string, int> price in prices) 
     { 
      end = price.Key; 
      count += price.Value; 
      totalCount += price.Value; 
      productsRemaining -= price.Value; 
      if (totalCount >= segmentSize * segmentIdx) 
      { 
       ranges.Add(new Tuple<string, string, int>(start, end, count)); 
       start = end; 
       count = 0; 
       segmentIdx += 1; 
      } 
      if (segmentIdx == nSegments) 
      { 
       ranges.Add(new Tuple<string, string, int>(start, "*", count + productsRemaining)); 
       break; 
      } 
     } 
     return ranges; 
    } 

फ़िल्टर परिणाम ("250", "500", 38) था परिणामी खंडों में से एक। यदि उपयोगकर्ता फ़िल्टर के रूप में "$ 250 से $ 500" का चयन करता है, तो बस एक फ़िल्टर क्वेरी fq=price:[250 TO 500]