रैवेनडीबी/ल्यूसीन का उपयोग कर Faceted खोज में पदानुक्रमित वर्गीकरण?

Question

मैं एक 'उन्नत पहलू खोज' परिदृश्य को लागू करने के लिए रावेनडीबी पर विचार कर रहा हूं।
मुझे पूर्ण पाठ खोज और अन्य सभी बुनियादी सुविधाओं का समर्थन करते हुए पेड़ की विभिन्न शाखाओं में एक जटिल पदानुक्रमिक वर्गीकरण और साझा पहलुओं से निपटना होगा।

क्या वहां कोई संसाधन है जो दस्तावेज़ को RavenDb API का उपयोग करके यह कैसे करें?

विषय पर Insanely जटिल कागज: Beyond Basic Faceted Search
Solr के रास्ते: HierarchicalFaceting

Answer 1

अंत में ..

using System.Collections.Generic; 
using System.Linq; 
using NUnit.Framework; 
using Raven.Abstractions.Data; 
using Raven.Client; 
using Raven.Client.Document; 
using Raven.Client.Indexes; 
using Raven.Client.Linq; 

namespace Prototype.Search.Tests 
{ 
    [TestFixture] 
    public class HierarchicalFaceting 
    { 
     // 
     // Document definition 
     // 
     public class Doc 
     { 
      public Doc() 
      { 
       Categories = new List<string>(); 
      } 

      public int Id { get; set; } 
      public List<string> Categories { get; set; } 
     } 

     // 
     // Data sample 
     // 
     public IEnumerable<Doc> GetDocs() 
     { 
      yield return new Doc { Id = 1, Categories = new List<string> { "0/NonFic", "1/NonFic/Law"} }; 
      yield return new Doc { Id = 2, Categories = new List<string> { "0/NonFic", "1/NonFic/Sci" } }; 
      yield return new Doc { Id = 3, Categories = new List<string> { "0/NonFic", "1/NonFic/Hist", "1/NonFic/Sci", "2/NonFic/Sci/Phys" } }; 
     } 

     // 
     // The index 
     // 
     public class DocByCategory : AbstractIndexCreationTask<Doc, DocByCategory.ReduceResult> 
     { 
      public class ReduceResult 
      { 
       public string Category { get; set; } 
      } 

      public DocByCategory() 
      { 
       Map = docs => 
         from d in docs 
         from c in d.Categories 
         select new 
           { 
            Category = c 
           }; 
      } 
     } 

     // 
     // FacetSetup 
     // 
     public FacetSetup GetDocFacetSetup() 
     { 
      return new FacetSetup 
         { 
          Id = "facets/Doc", 
          Facets = new List<Facet> 
             { 
              new Facet 
               { 
                Name = "Category" 
               } 
             } 
         }; 
     } 

     [SetUp] 
     public void SetupDb() 
     { 
      IDocumentStore store = new DocumentStore() 
      { 
       Url = "http://localhost:8080" 
      }; 
      store.Initialize(); 
      IndexCreation.CreateIndexes(typeof(HierarchicalFaceting).Assembly, store); 

      var session = store.OpenSession(); 
      session.Store(GetDocFacetSetup()); 
      session.SaveChanges(); 

      store.Dispose(); 
     } 

     [Test] 
     [Ignore] 
     public void DeleteAll() 
     { 
      IDocumentStore store = new DocumentStore() 
      { 
       Url = "http://localhost:8080" 
      }; 
      store.Initialize(); 

      store.DatabaseCommands.DeleteIndex("Raven/DocByCategory"); 
      store.DatabaseCommands.DeleteByIndex("Raven/DocumentsByEntityName", new IndexQuery()); 

      store.Dispose(); 
     } 

     [Test] 
     [Ignore] 
     public void StoreDocs() 
     { 
      IDocumentStore store = new DocumentStore() 
      { 
       Url = "http://localhost:8080" 
      }; 
      store.Initialize(); 

      var session = store.OpenSession(); 

      foreach (var doc in GetDocs()) 
      { 
       session.Store(doc); 
      } 

      session.SaveChanges(); 
      session.Dispose(); 
      store.Dispose(); 
     } 

     [Test] 
     public void QueryDocsByCategory() 
     { 
      IDocumentStore store = new DocumentStore() 
      { 
       Url = "http://localhost:8080" 
      }; 
      store.Initialize(); 

      var session = store.OpenSession(); 

      var q = session.Query<DocByCategory.ReduceResult, DocByCategory>() 
       .Where(d => d.Category == "1/NonFic/Sci") 
       .As<Doc>(); 

      var results = q.ToList(); 
      var facetResults = q.ToFacets("facets/Doc").ToList(); 

      session.Dispose(); 
      store.Dispose(); 
     } 

     [Test] 
     public void GetFacets() 
     { 
      IDocumentStore store = new DocumentStore() 
      { 
       Url = "http://localhost:8080" 
      }; 
      store.Initialize(); 

      var session = store.OpenSession(); 

      var q = session.Query<DocByCategory.ReduceResult, DocByCategory>() 
       .Where(d => d.Category.StartsWith("1/NonFic")) 
       .As<Doc>(); 

      var results = q.ToList(); 
      var facetResults = q.ToFacets("facets/Doc").ToList(); 

      session.Dispose(); 
      store.Dispose(); 
     } 
    } 
} 

Answer 2

मैं गति के लिये इस का उपयोग कर शुद्ध Lucene के वृक्ष की खोज हिस्सा संभाल होगा। 2 दृष्टिकोण माता-पिता-संबंध संबंध विधि और पथ-गणना/'डेवी दशमलव' विधि हैं।

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

How to store tree data in a Lucene/Solr/Elasticsearch index or a NoSQL db? पथ-गणना/'डेवी दशमलव' विधि को शामिल करता है।

या तो दृष्टिकोण मनमाने ढंग से जटिल पदानुक्रम को संभाल सकता है, जब तक कि यह एक वास्तविक पदानुक्रम (यानी एक निर्देशित विश्वकोश ग्राफ (डीएजी)) हो।

Answer 3

मैं यह पहले से ही तय की।

मैं इस प्रकार सूचकांक बनाने के लिए:

public class ProductByCategory : AbstractIndexCreationTask<Product, ProductByCategory.ReduceResult> 
{ 
    public class ReduceResult 
    { 
     public string Category { get; set; } 
     public string Title { get; set; } 
    } 

    public ProductByCategory() 
    { 
     Map = products => 
       from p in products 
       from c in p.Categories 
       select new 
       { 
        Category = c, 
        Title = p.Title 
       }; 
     Stores.Add(x => x.Title, FieldStorage.Yes); 
     Indexes.Add(x => x.Title, FieldIndexing.Analyzed); 
    } 
} 

और मुझे यह पसंद है क्वेरी:

var q = session.Query<ProductByCategory.ReduceResult, ProductByCategory>().Search(x => x.Title, "Sony") 
.Where(r => r.Category.StartsWith("1/beeld en geluid")).As<Product>(); 

var facetResults = q.ToFacets("facets/ProductCategory");