Seleziona * group by in mongo aggregation

Question

Sto cercando di fare qualcosa che ritengo sia abbastanza semplice. Supponiamo che io abbia una serie di record in mongo che hanno una chiave comune e un numero variabile di attributi. Voglio selezionare tutti gli attributi e raggruppare per nome tra i record. Per esempio

{ Name: George, x: 5, y: 3 } 
{ Name: George, z: 9 } 
{ Name: Rob, x: 12, y: 2 } 

vorrei produrre un CSV che assomiglia a questo:

Name  X Y Z 
George 5 3 9 
Rob  12 2 

provato

DB.data.aggregate({ $group : { _id : "$Name" } }) 

Purtroppo torno tutti i nomi come record, ma non l'unione di tutti gli attributi possibili.

Answer 1

Se si desidera combinare gli attributi, è necessario aggiungerli allo group. Ad esempio, utilizzando $addToSet per trovare i valori unici delle x, y, attributi z raggruppati per ogni nome:

db.data.aggregate(
    { $group : { 
      _id : "$Name", 
      x: { $addToSet: "$x" }, 
      y: { $addToSet: "$y" }, 
      z: { $addToSet: "$z" }, 
    }} 
) 

Returns:

{ 
    "result" : [ 
     { 
      "_id" : "Rob", 
      "x" : [ 
       12 
      ], 
      "y" : [ 
       2 
      ], 
      "z" : [ ] 
     }, 
     { 
      "_id" : "George", 
      "x" : [ 
       5 
      ], 
      "y" : [ 
       3 
      ], 
      "z" : [ 
       9 
      ] 
     } 
    ], 
    "ok" : 1 
} 

Answer 2

Ecco l'altro modo di farlo:

$connection = 'mongodb://localhost:27017'; 
$con  = new Mongo($connection); // mongo connection 

$db   = $con->test; /// database 
$collection = $db->prb; // table 

$keys  = array("Name" => 1,"x"=>1,"y"=>1,"z"=>1); 

// set intial values 
$initial = array("count" => 0); 

// JavaScript function to perform 
$reduce  = "function (obj, prev) { prev.count++; }"; 

$g   = $collection->group($keys, $initial, $reduce); 

echo "<pre>"; 
print_r($g); 

Si otterrà la risposta qualcosa di simile (non l'uscita esatta):

0.123.

Array 
(
    [retval] => Array 
     (
      [0] => Array 
       (
        [Name] => George 
        [x] => 
        [y] => 
        [z] => 
        [count] => 2 
       ) 

      [1] => Array 
       (
        [Name] => Rob 
        [x] => 
        [y] => 
        [z] => 
        [count] => 1 
       ) 

     ) 

    [count] => 5 
    [keys] => 3 
    [ok] => 1 
) 

Answer 3

uso $addToSet al gruppo, funzionerà

db.data.aggregate(
    { $group : { 
      _id : "$Name", 
      x: { $addToSet: "$x" }, 
      y: { $addToSet: "$y" }, 
      z: { $addToSet: "$z" }, 
    }} 
) 

Answer 4

La soluzione da Stennie richiede di sapere esattamente quali attributi che si desidera tornare da ogni voce corrispondente nella collezione si sta interrogando. Questo non è sempre il caso.

Abbiamo dovuto risolvere questo problema all'interno di un'applicazione Groovy on Grails che stiamo scrivendo.

abbiamo scritto un metodo come questo per gestire la "trovare da X" richieste:

private List<DBObject> findDistinctPages(Map by) { 
    def command = 
     new GroupCommand(
       (DBCollection) db.pages, 
       new BasicDBObject(['url': 1]), 
       new BasicDBObject(by), 
       new BasicDBObject([:]), 
       'function (current, result) { for(i in current) { result[i] = current[i] } }', 
       '' 
     ) 
    db.pages.group(command).sort { it.title } 
} 

E poi chiamare all'interno del nostro codice come segue:

def pages = findDistinctPages([$or: [[type: 'channel'], [type: 'main']]]) 

Questo funziona facendo passare i risultati della query iniziale alla funzione javascript alla fine di GroupCommand. Mongo restituisce solo gli attributi che hai specificato nella query iniziale e nient'altro, quindi devi eseguire un'iterazione sui risultati una seconda volta, popolandoli con il resto dei dati di mongo.