db4o sortieren

[Luckie]

Ich will also meine Datensätze sortieren, nur leider bringt die Datenbank dafür nichts mit. Als Workaround wird hier gesagt:

Zitat:

das ObjectSet in eine Collection zu kopieren und dann Collections.sort() darauf aufzurufen).

So bekomme ich alle datensätze in ein ObjectSet:

Code:

public IList<Person> Sort()
        {
            Person prs = new Person(null, null, 0);
            ObjectSet os = oc.Get(prs);
        }

und wie jetzt weiter? :gruebel:

[MathiasSimmack]

Gab es nicht bei Datenbanken die Möglichkeit, die Query-Ergebnisse gleich so zu filtern, dass sie unter Umständen schon sortiert ankommen? :gruebel: Wenn nicht, dann meinen die im Forum wohl den Weg, dass du die Ergebnisse der Datenbank in eine Liste (= Collection) kopierst und dann selbst eine Sortierroutine ansetzt.

Keine Ahnung, ob das besonders elegant ist (wo ist der Robert, wenn man ihn mal braucht? :zwinker:), aber es funktioniert:

Code:

public List<Person> SortByAge()
{
   IList<Person> personen  = oc.Query<Person> (typeof(Person));
   List<Person> sortedList = new List<Person>(personen);
   AgeComparer ageCompare  = new AgeComparer();

   sortedList.Sort(ageCompare);
   return sortedList;
}

class AgeComparer : IComparer<Person>
{
   public int Compare(Person a, Person b)
   {
      return decimal.Compare(a.Alter, b.Alter);
   }
}


// Beispiel:

Queries queries = new Queries(db);
List<Person> sortedResult = queries.SortByAge();
foreach(Person person4 in sortedResult)
{
   Console.WriteLine("{0} ist {1} Jahre alt", person4.Name, person4.Alter);
}

[Elvis]

Ich habe mal den Rest der Mittagspause geopfert um das hier runterzuhacken.
Ist eigentlich nur ein billiger Quicksort, welcher entweder mit einem IComparer<T> oder einem delegate arbeitet:

Code:

public static class QuickSorter<T>
{
  public static void Sort(IList<T> list)
  {
    Sort(list, Comparer<T>.Default);
  }

  public static void Sort(IList<T> list, IComparer<T> comparer)
  {
    Sort(list, comparer, 0, list.Count - 1);
  }

  public static void Sort(IList<T> list, Comparison<T> comparison)
  {
    Sort(list, comparison, 0, list.Count - 1);
  }

  public static void Sort(IList<T> list, int lowerBound, int upperBound)
  {
    IComparer<T> comparer = Comparer<T>.Default;
    Sort(list, comparer, lowerBound, upperBound);
  }

  public static void Sort(IList<T> list, IComparer<T> comparer, int lowerBound, int upperBound)
  {
    if (lowerBound < upperBound)
    {
      int split = Partition(list, comparer, lowerBound, upperBound);
      Sort(list, comparer, lowerBound, split - 1);
      Sort(list, comparer, split + 1, upperBound);
    }
  }

  public static void Sort(IList<T> list,
                          Comparison<T> comparison,
                          int lowerBound,
                          int upperBound)
  {
    if (lowerBound < upperBound)
    {
      int split = Partition(list, comparison, lowerBound, upperBound);
      Sort(list, comparison, lowerBound, split - 1);
      Sort(list, comparison, split + 1, upperBound);
    }
  }
  
  static int Partition(IList<T> list,
                       IComparer<T> comparer,
                       int lowerBound,
                       int upperBound)
  {
    int left = lowerBound + 1;
    int right = upperBound;

    T pivot = list[lowerBound];
    T swap = default(T);

    while (left <= right)
    {
      while (left <= right && comparer.Compare(list[left], pivot) <= 0)
        left++;
      while (left <= right && comparer.Compare(list[right], pivot) > 0)
        right--;

      if (left < right)
      {
        swap = list[left];
        list[left] = list[right];
        list[right] = swap;
        left++;
        right--;
      }
    }

    swap = list[lowerBound];
    list[lowerBound] = list[right];
    list[right] = swap;
    return right;
  }

  static int Partition(IList<T> list,
                       Comparison<T> comparison,
                       int lowerBound,
                       int upperBound)
  {
    int left = lowerBound + 1;
    int right = upperBound;

    T pivot = list[lowerBound];
    T swap;

    while (left <= right)
    {

      while (left <= right && comparison(list[left], pivot) <= 0)
        left++;
      while (left <= right && comparison(list[right], pivot) > 0)
        right--;

      if (left < right)
      {
        swap = list[left];
        list[left] = list[right];
        list[right] = swap;
        left++;
        right--;
      }
    }

    swap = list[lowerBound];
    list[lowerBound] = list[right];
    list[right] = swap;
    return right;
  }
}

Er ist wirklich nur schnell auf Vorlage von irgendeinem Quicksort runtergerödelt, also kein Gewehr. :P

Benutzen kannst du ihn mit jeder IList<T> Implementierung (Die Java deklaration auf deren Seite sieht mir sehr nach einem generischen Container aus ;) ):

Code:

ObjectSet<Person> os = oc.Get(prs); 
QuickSorter<Person>.Sort(os, delegate(Person left, Person right)
                             { return left.Name.CompareTo(right.Name); });