LINQ-Abfrage, um Schlüsselanzahl-Wertepaare auszugeben

Question

Es gibt ungefähr eine halbe Million RavenDB-Dokumente von Kunden. Eine der Eigenschaften ist "City".. wie kann ich eine LINQ-Abfrage schreiben, um eine Liste aller Vorkommen jeder Stadt mit ihrer Anzahl zu erhalten. Wenn zum Beispiel tausend Kundendokumente den Wert "NY" als Stadt haben, benötige ich eine Liste von Städten mit Zählung wie NY 1000; LA 200, OR 1300, BO 5000 etc..

Das ist das, was ich ursprünglich geschrieben habe.

 Dictionary cityStats = session.Query()
                    .ToList()
                    .GroupBy(x => x.City)
                    .OrderBy(x => x.Count())
                    .ToDictionary(x => x.Key, x => x.Count());

Aber das sieht nicht so aus, als ob es mir genaue Ergebnisse liefert.. also habe ich die Eigenschaft für die maximale Anzahl an Anfragen geändert (ich weiß, dass es nicht empfohlen wird), nur um zu sehen, ob sich das Ergebnis ändert.. aber der Wert für maximal zulässige Anfragen von 500.000 bringt mir auch dasselbe Ergebnis. Ich weiß sicher, dass es ungefähr eine halbe Million Kundendokumente gibt, also müssen sie übereinstimmen.

Answer 1

Sie benötigen einen Map-Reduce-Index, um dies zu tun. Hier ist ein kurzes Konsolenprogramm, das das demonstriert:

using System;
using System.Linq;
using Raven.Client.Document;
using Raven.Client.Indexes;

namespace ConsoleApplication1
{
  public class Customer
  {
    public string Id { get; set; }
    public string Name { get; set; }
    public string City { get; set; }
  }

  public class Customers_ByCity : AbstractIndexCreationTask
  {
    public Customers_ByCity()
    {
      Map = customers => from customer in customers
                         select new
                         {
                           customer.City,
                           Count = 1
                         };

      Reduce = results => from result in results
                          group result by result.City
                          into g
                          select new
                          {
                            City = g.Key,
                            Count = g.Sum(x => x.Count)
                          };
    }

    public class Result
    {
      public string City { get; set; }
      public int Count { get; set; }
    }
  }

  class Program
  {
    private static void Main()
    {
      var documentStore = new DocumentStore { Url = "http://localhost:8080" };
      documentStore.Initialize();
      IndexCreation.CreateIndexes(typeof(Program).Assembly, documentStore);

      using (var session = documentStore.OpenSession())
      {
        session.Store(new Customer { Name = "John", City = "NY" });
        session.Store(new Customer { Name = "Jane", City = "NY" });
        session.Store(new Customer { Name = "Jim", City = "NY" });
        session.Store(new Customer { Name = "Sally", City = "LA" });
        session.Store(new Customer { Name = "Sam", City = "LA" });
        session.Store(new Customer { Name = "Suzie", City = "LA" });
        session.Store(new Customer { Name = "Sarah", City = "LA" });

        session.SaveChanges();
      }

      using (var session = documentStore.OpenSession())
      {
        // In einer realen Anwendung wollen Sie wahrscheinlich nicht auf nicht-aktuelle Ergebnisse warten.
        // Sie sollten auch darüber nachdenken, was zu tun ist, wenn Sie mehr als eine Seite mit Ergebnissen haben (mehr als 1024 Städte)

        var counts = session.Query()
          .Customize(x=> x.WaitForNonStaleResults())
          .Take(1024);

        foreach (var result in counts)
        {
          Console.WriteLine("{0}: {1}", result.City, result.Count);
        }

        Console.WriteLine();
      }
      Console.ReadLine();
    }
  }
}