Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# $bucketAuto
<a name="bucketAuto"></a>

Nuovo dalla versione 8.0.2.

La fase di `$bucketAuto` aggregazione in Amazon DocumentDB raggruppa automaticamente i documenti di input in un numero specificato di bucket in base a un'espressione specificata. A differenza `$bucket` di quanto avviene quando si definiscono esplicitamente i limiti dei bucket, i limiti `$bucketAuto` vengono determinati automaticamente in modo che i documenti siano distribuiti nel modo più uniforme possibile sul numero di bucket richiesto. Ciò può essere utile quando si desidera classificare i dati in un numero fisso di gruppi senza conoscere in anticipo la distribuzione dei valori.

**Parametri**
+ `groupBy`(obbligatorio): l'espressione che specifica il valore in base al quale raggruppare.
+ `buckets`(obbligatorio): un numero intero positivo che specifica il numero di bucket in cui sono raggruppati i documenti. A seconda dei documenti di input e dell'`groupBy`espressione, il numero effettivo di bucket può essere inferiore al numero specificato.
+ `output`(opzionale): un oggetto che specifica le informazioni da emettere per ogni bucket. È possibile utilizzare operatori di accumulo come`$sum`, `$avg``$min`, e `$max` per calcolare le aggregazioni per ogni bucket. Se omesso, ogni bucket genera un campo per impostazione predefinita. `count`
+ `granularity`(opzionale): una stringa che specifica la serie numerica preferita da utilizzare per i limiti del bucket. Questo aggancia i limiti calcolati a una progressione numerica standard. Questo parametro è disponibile solo se tutti i `groupBy` valori sono numerici e nessuno lo è. `NaN` I valori validi sono: `R5``R10`,`R20`,`R40`,`R80`,`1-2-5`,`E6`,`E12`,`E24`,,`E48`, `E96``E192`, e`POWERSOF2`.

**Output**

Ogni bucket viene restituito come documento separato che contiene un `_id` oggetto che descrive i limiti del bucket:
+ `_id.min`: Il limite inferiore incluso del bucket.
+ `_id.max`: Il limite superiore del secchio. Questo limite è esclusivo per ogni bucket tranne l'ultimo bucket della serie, dove è incluso.

## Esempio (MongoDB Shell)
<a name="bucketAuto-examples"></a>

L'esempio seguente dimostra come utilizzare la `$bucketAuto` fase per raggruppare i dati di vendita in bucket in base al prezzo.

**Crea documenti di esempio **

```
db.sales.insertMany([
  { item: "abc", price: 10, quantity: 2, date: new Date("2020-09-01") },
  { item: "def", price: 20, quantity: 1, date: new Date("2020-10-01") },
  { item: "ghi", price: 5, quantity: 3, date: new Date("2020-11-01") },
  { item: "jkl", price: 15, quantity: 2, date: new Date("2020-12-01") },
  { item: "mno", price: 25, quantity: 1, date: new Date("2021-01-01") }
]);
```

**Esempio di interrogazione **

Il comando seguente raggruppa i documenti di esempio in tre fasce in base al prezzo:

```
db.sales.aggregate([
  {
    $bucketAuto: {
      groupBy: "$price",
      buckets: 3,
      output: {
        "count": { $sum: 1 },
        "totalQuantity": { $sum: "$quantity" }
      }
    }
  }
])
```

**Output**

Questo comando restituisce il seguente output:

```
[
  { _id: { min: 5, max: 15 }, count: 2, totalQuantity: 5 },
  { _id: { min: 15, max: 25 }, count: 2, totalQuantity: 3 },
  { _id: { min: 25, max: 25 }, count: 1, totalQuantity: 1 }
]
```

**Esempio di interrogazione con granularità **

L'esempio seguente aggiunge l'`granularity`opzione per agganciare i limiti del bucket calcolati a potenze di 2.

```
db.sales.aggregate([
  {
    $bucketAuto: {
      groupBy: "$price",
      buckets: 2,
      granularity: "POWERSOF2",
      output: {
        "count": { $sum: 1 },
        "totalQuantity": { $sum: "$quantity" }
      }
    }
  }
])
```

**Output**

Questo comando restituisce il seguente output:

```
[
  { _id: { min: 4, max: 16 }, count: 3, totalQuantity: 7 },
  { _id: { min: 16, max: 32 }, count: 2, totalQuantity: 2 }
]
```

## Esempi di codice
<a name="bucketAuto-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del `$bucketAuto` comando, scegliete la scheda corrispondente alla lingua che desiderate utilizzare:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function example() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const sales = db.collection('sales');

  const result = await sales.aggregate([
    {
      $bucketAuto: {
        groupBy: "$price",
        buckets: 3,
        output: {
          "count": { $sum: 1 },
          "totalQuantity": { $sum: "$quantity" }
        }
      }
    }
  ]).toArray();

  console.log(result);
  client.close();
}

example();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def example():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client['test']
    sales = db['sales']

    result = list(sales.aggregate([
        {
            '$bucketAuto': {
                'groupBy': '$price',
                'buckets': 3,
                'output': {
                    'count': {'$sum': 1},
                    'totalQuantity': {'$sum': '$quantity'}
                }
            }
        }
    ]))

    print(result)
    client.close()

example()
```

------