Есть ли способ эффективно выполнить эквивалент DENSE_RANK в MongoDB?

SQL Server и Oracle имеют функции DENSE_RANK. Есть ли способ сделать нечто подобное в MongoDB, не прибегая к MapReduce? Другими словами, предположим, что у вас есть предложение выбора T-SQL, например:

SELECT DENSE_RANK() OVER(ORDER BY SomeField DESC) SomeRank

Каков наилучший способ сделать то же самое в MongoDB?

(Примечание: это репост вопроса MongoDB здесь . Я надеюсь получить больше отзывов от администраторов баз данных ...)

MongoDB не имеет никакой концепции ранжирования. Самое близкое, что я смог найти, это отсюда :

Вот некоторые примеры данных:

 > db.scoreboard.find()`
 { "_id" : ObjectId("4d99f71450f0ae2165669ea9"), "user" : "dave", "score" : 4 }
 { "_id" : ObjectId("4d99f71b50f0ae2165669eaa"), "user" : "steve", "score" : 5 }`
 { "_id" : ObjectId("4d99f72350f0ae2165669eab"), "user" : "tom", "score" : 3 }

Сначала найдите оценку пользователя «Дейв»:

 db.scoreboard.find({ user : "dave" }, { score : 1 }) { "_id" : ObjectId("4d99f71450f0ae2165669ea9"), "score" : 4 }

Затем посчитайте, сколько пользователей имеют более высокий балл:

 db.scoreboard.find({ score : { $gt : 4 }}).count() 
 1

Поскольку существует 1 более высокий балл, ранг Дейва равен 2 (просто добавьте 1 к количеству более высоких баллов, чтобы получить ранг).

Очевидно, это далеко от идеала. Однако MongoDB просто не имеет какой-либо функциональности для этого, поскольку он просто не предназначен для этого типа запросов.

После некоторых экспериментов я обнаружил, что можно построить функцию ранжирования на основе MapReduce, предполагая, что набор результатов может соответствовать максимальному размеру документа.

Например, предположим, у меня есть такая коллекция:

{ player: "joe", points: 1000, foo: 10, bar: 20, bang: "some text" }
{ player: "susan", points: 2000, foo: 10, bar: 20, bang: "some text" }
{ player: "joe", points: 1500, foo: 10, bar: 20, bang: "some text" }
{ player: "ben", points: 500, foo: 10, bar: 20, bang: "some text" }
...

Я могу выполнить грубый эквивалент DENSE_RANK следующим образом:

var m = function() { 
  ++g_counter; 

  if ((this.player == "joe") && (g_scores.length != g_fake_limit)) { 
    g_scores.push({
      player: this.player, 
      points: this.points, 
      foo: this.foo,
      bar: this.bar,
      bang: this.bang,
      rank: g_counter
    });   
  }

  if (g_counter == g_final)
  {
    emit(this._id, g_counter);
  }
}}


var r = function (k, v) { }
var f = function(k, v) { return g_scores; }

var test_mapreduce = function (limit) {
  var total_scores = db.scores.count();

  return db.scores.mapReduce(m, r, {
    out: { inline: 1 }, 
    sort: { points: -1 }, 
    finalize: f, 
    limit: total_scores, 
    verbose: true,
    scope: {
      g_counter: 0, 
      g_final: total_scores, 
      g_fake_limit: limit, 
      g_scores:[]
    }
  }).results[0].value;
}

Для сравнения, вот «наивный» подход, упомянутый в другом месте:

var test_naive = function(limit) {
  var cursor = db.scores.find({player: "joe"}).limit(limit).sort({points: -1});
  var scores = [];

  cursor.forEach(function(score) {
    score.rank = db.scores.count({points: {"$gt": score.points}}) + 1;
    scores.push(score);
  });

  return scores;
}

Я протестировал оба подхода на одном экземпляре MongoDB 1.8.2, используя следующий код:

var rand = function(max) {
  return Math.floor(Math.random() * max);
}

var create_score = function() {
  var names = ["joe", "ben", "susan", "kevin", "lucy"]
  return { player: names[rand(names.length)], points: rand(1000000), foo: 10, bar: 20, bang: "some kind of example text"};
}

var init_collection = function(total_records) {
  db.scores.drop();

  for (var i = 0; i != total_records; ++i) {
    db.scores.insert(create_score());
  }

  db.scores.createIndex({points: -1})
}


var benchmark = function(test, count, limit) {
  init_collection(count);

  var durations = [];
  for (var i = 0; i != 5; ++i) {
    var start = new Date;
    result = test(limit)
    var stop = new Date;

    durations.push(stop - start);
  }

  db.scores.drop();

  return durations;
}

Хотя MapReduce был быстрее, чем я ожидал, наивный подход выкинул его из воды для больших коллекционных размеров, особенно после того, как кеш прогрелся:

> benchmark(test_naive, 1000, 50);
[ 22, 16, 17, 16, 17 ]
> benchmark(test_mapreduce, 1000, 50);
[ 16, 15, 14, 11, 14 ]
> 
> benchmark(test_naive, 10000, 50);
[ 56, 16, 17, 16, 17 ]
> benchmark(test_mapreduce, 10000, 50);
[ 154, 109, 116, 109, 109 ]
> 
> benchmark(test_naive, 100000, 50);
[ 492, 15, 18, 17, 16 ]
> benchmark(test_mapreduce, 100000, 50);
[ 1595, 1071, 1099, 1108, 1070 ]
> 
> benchmark(test_naive, 1000000, 50);
[ 6600, 16, 15, 16, 24 ]
> benchmark(test_mapreduce, 1000000, 50);
[ 17405, 10725, 10768, 10779, 11113 ]

Итак, на данный момент похоже, что наивный подход - это путь, хотя мне будет интересно посмотреть, изменится ли история позже в этом году, когда команда MongoDB продолжает улучшать производительность MapReduce.