DOCSP-26417: use struct in aggregation pg (#209)

* DOCSP-26415: structs in agg pg

* first pass fixes

* spacing fix

* MW small fixes

Author: rustagir

source/fundamentals/aggregation.txt

@@ -85,6 +85,15 @@ operations, keep the following in mind:
 Examples
 --------
 
+The examples in this section use the following ``Tea`` struct as a model for documents
+in the ``menu`` collection:
+
+.. literalinclude:: /includes/fundamentals/code-snippets/aggregation.go
+   :start-after: start-tea-struct
+   :end-before: end-tea-struct
+   :language: go
+   :dedent:
+
 To run the examples in this section, load the sample data into the
 ``tea.menu`` collection with the following snippet:
 
@@ -94,16 +103,16 @@ To run the examples in this section, load the sample data into the
    :language: go
    :dedent:
 
-Each document represents a tea on the menu of a shop. It conatains
-information about the tea type, the toppings you can add, and its price.
+Each document represents a tea on the menu of a shop and contains
+information about the tea type, the available toppings, and the price.
 
 Average Rating
 ~~~~~~~~~~~~~~
 
 The following example calculates and displays the average rating and
-amount of ratings for each tea.
+number of ratings for each tea category.
 
-The aggregation pipleline uses the ``$group`` stage to group the
+The aggregation pipeline uses the ``$group`` stage to group the
 documents by the ``category`` field, calculates the average using the
 ``$avg`` expression operator, and counts the number of documents using
 the ``$sum`` expression operator.
@@ -114,54 +123,49 @@ the ``$sum`` expression operator.
    .. input::
       :language: go
 
-      // create the stage
+      // create group stage
       groupStage := bson.D{
           {"$group", bson.D{
               {"_id", "$category"},
-              {"average_price", bson.D{
-                  {"$avg", "$price"},
-              }},
-              {"type_total", bson.D{
-                  {"$sum", 1},
-              }},
-      }}}
-
-      // pass the stage into a pipeline
-      // pass the pipeline as the second paramter in the Aggregate() method
+              {"average_price", bson.D{{"$avg", "$price"}}},
+              {"type_total", bson.D{{"$sum", 1}}},
+          }}}
+      
+      // pass the pipeline to the Aggregate() method
       cursor, err := coll.Aggregate(context.TODO(), mongo.Pipeline{groupStage})
       if err != nil {
           panic(err)
       }
-
+      
       // display the results
       var results []bson.M
       if err = cursor.All(context.TODO(), &results); err != nil {
           panic(err)
       }
       for _, result := range results {
-          fmt.Printf("Average price of %v tea: $%v \n", result["_id"], result["average_price"])
-          fmt.Printf("Amount of %v tea: %v \n\n", result["_id"], result["type_total"])
+          fmt.Printf("Average price of %v tea options: $%v \n", result["_id"], result["average_price"])
+          fmt.Printf("Number of %v tea options: %v \n\n", result["_id"], result["type_total"])
       }
 
    .. output::
       :language: none
       :visible: false
 
-      Average price of black tea: $6.075 
-      Amount of black tea: 4 
+      Average price of black tea options: $6.075
+      Number of black tea options: 4 
 
-      Average price of green tea: $5.7 
-      Amount of green tea: 4 
+      Average price of green tea options: $5.70
+      Number of green tea options: 4  
 
 Omit Fields in Results
 ~~~~~~~~~~~~~~~~~~~~~~
 
 The following example matches documents where you can get milk foam as a
 topping and lists the two cheapest options.
 
-The aggregation pipleline contains the following stages:
+The aggregation pipeline contains the following stages:
 
-- ``$match`` stage to match documents where its ``toppings`` contain "milk foam"
+- ``$match`` stage to match documents where the ``toppings`` field contains "milk foam"
 - ``$unset`` stage to omit the ``_id`` and ``category`` fields
 - ``$sort`` stage to sort the ``price`` and ``toppings`` in ascending order
 - ``$limit`` stage to show the first two documents
@@ -175,38 +179,34 @@ The aggregation pipleline contains the following stages:
       // create the stages
       matchStage := bson.D{{"$match", bson.D{{"toppings", "milk foam"}}}}
       unsetStage := bson.D{{"$unset", bson.A{"_id", "category"}}}
-      sortStage := bson.D{{"$sort", bson.D{
-          {"price", 1},
-          {"toppings", 1}},
-      }}
+      sortStage := bson.D{{"$sort", bson.D{{"price", 1}, {"toppings", 1}}}}
       limitStage := bson.D{{"$limit", 2}}
-
-      // pass the stage into a pipeline
-      // pass the pipeline as the second paramter in the Aggregate() method
+      
+      // pass the pipeline to the Aggregate() method
       cursor, err := coll.Aggregate(context.TODO(), mongo.Pipeline{matchStage, unsetStage, sortStage, limitStage})
       if err != nil {
           panic(err)
       }
-
+      
       // display the results
-      var results []bson.M
+      var results []Tea
       if err = cursor.All(context.TODO(), &results); err != nil {
           panic(err)
       }
       for _, result := range results {
-          fmt.Printf("Tea: %v \nToppings: %v \nPrice: $%v \n\n", result["type"], result["toppings"], result["price"])
+          fmt.Printf("Tea: %v \nToppings: %v \nPrice: $%v \n\n", result.Type, strings.Join(result.Toppings, ", "), result.Price)
       }
 
    .. output::
       :language: none
       :visible: false
 
       Tea: Hojicha 
-      Toppings: [lemon ginger milk foam] 
+      Toppings: lemon, ginger, milk foam 
       Price: $5.55 
-
+      
       Tea: Gyokuro 
-      Toppings: [berries milk foam] 
+      Toppings: berries, milk foam 
       Price: $5.65 
 
 Additional Information
@@ -238,5 +238,4 @@ To learn more about any of the methods or types discussed in this
 guide, see the following API Documentation:
 
 - `Aggregate() <{+api+}/mongo#Collection.Aggregate>`__
-- `AggregateOptions <{+api+}/mongo/options#AggregateOptions>`__
-
+- `AggregateOptions <{+api+}/mongo/options#AggregateOptions>`__

source/includes/fundamentals/code-snippets/aggregation.go

@@ -5,12 +5,23 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"strings"
 
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
 )
 
+// start-tea-struct
+type Tea struct {
+	Type     string
+	Category string
+	Toppings []string
+	Price    float32
+}
+
+// end-tea-struct
+
 func main() {
 	var uri string
 	if uri = os.Getenv("MONGODB_URI"); uri == "" {
@@ -31,34 +42,32 @@ func main() {
 	// begin insert docs
 	coll := client.Database("tea").Collection("menu")
 	docs := []interface{}{
-		bson.D{{"type", "Masala"}, {"category", "black"}, {"toppings", bson.A{"ginger", "pumpkin spice", "cinnomon"}}, {"price", 6.75}},
-		bson.D{{"type", "Gyokuro"}, {"category", "green"}, {"toppings", bson.A{"berries", "milk foam"}}, {"price", 5.65}},
-		bson.D{{"type", "English Breakfast"}, {"category", "black"}, {"toppings", bson.A{"whipped cream", "honey"}}, {"price", 5.75}},
-		bson.D{{"type", "Sencha"}, {"category", "green"}, {"toppings", bson.A{"lemon", "whipped cream"}}, {"price", 5.15}},
-		bson.D{{"type", "Assam"}, {"category", "black"}, {"toppings", bson.A{"milk foam", "honey", "berries"}}, {"price", 5.65}},
-		bson.D{{"type", "Matcha"}, {"category", "green"}, {"toppings", bson.A{"whipped cream", "honey"}}, {"price", 6.45}},
-		bson.D{{"type", "Earl Grey"}, {"category", "black"}, {"toppings", bson.A{"milk foam", "pumpkin spice"}}, {"price", 6.15}},
-		bson.D{{"type", "Hojicha"}, {"category", "green"}, {"toppings", bson.A{"lemon", "ginger", "milk foam"}}, {"price", 5.55}},
+		Tea{Type: "Masala", Category: "black", Toppings: []string{"ginger", "pumpkin spice", "cinnamon"}, Price: 6.75},
+		Tea{Type: "Gyokuro", Category: "green", Toppings: []string{"berries", "milk foam"}, Price: 5.65},
+		Tea{Type: "English Breakfast", Category: "black", Toppings: []string{"whipped cream", "honey"}, Price: 5.75},
+		Tea{Type: "Sencha", Category: "green", Toppings: []string{"lemon", "whipped cream"}, Price: 5.15},
+		Tea{Type: "Assam", Category: "black", Toppings: []string{"milk foam", "honey", "berries"}, Price: 5.65},
+		Tea{Type: "Matcha", Category: "green", Toppings: []string{"whipped cream", "honey"}, Price: 6.45},
+		Tea{Type: "Earl Grey", Category: "black", Toppings: []string{"milk foam", "pumpkin spice"}, Price: 6.15},
+		Tea{Type: "Hojicha", Category: "green", Toppings: []string{"lemon", "ginger", "milk foam"}, Price: 5.55},
 	}
 
 	result, err := coll.InsertMany(context.TODO(), docs)
+	// end insert docs
+
 	if err != nil {
 		panic(err)
 	}
-	// end insert docs
+
 	fmt.Printf("Number of documents inserted: %d\n", len(result.InsertedIDs))
 
-	fmt.Println("Average:")
+	fmt.Println("\nAggregation Example - Average\n")
 	{
 		groupStage := bson.D{
 			{"$group", bson.D{
 				{"_id", "$category"},
-				{"average_price", bson.D{
-					{"$avg", "$price"},
-				}},
-				{"type_total", bson.D{
-					{"$sum", 1},
-				}},
+				{"average_price", bson.D{{"$avg", "$price"}}},
+				{"type_total", bson.D{{"$sum", 1}}},
 			}}}
 
 		cursor, err := coll.Aggregate(context.TODO(), mongo.Pipeline{groupStage})
@@ -71,32 +80,29 @@ func main() {
 			panic(err)
 		}
 		for _, result := range results {
-			fmt.Printf("Average price of %v tea: $%v \n", result["_id"], result["average_price"])
-			fmt.Printf("Amount of %v tea: %v \n\n", result["_id"], result["type_total"])
+			fmt.Printf("Average price of %v tea options: $%v \n", result["_id"], result["average_price"])
+			fmt.Printf("Number of %v tea options: %v \n\n", result["_id"], result["type_total"])
 		}
 	}
 
-	fmt.Println("Unset:")
+	fmt.Println("\nAggregation Example - Unset\n")
 	{
 		matchStage := bson.D{{"$match", bson.D{{"toppings", "milk foam"}}}}
 		unsetStage := bson.D{{"$unset", bson.A{"_id", "category"}}}
-		sortStage := bson.D{{"$sort", bson.D{
-			{"price", 1},
-			{"toppings", 1}},
-		}}
+		sortStage := bson.D{{"$sort", bson.D{{"price", 1}, {"toppings", 1}}}}
 		limitStage := bson.D{{"$limit", 2}}
 
 		cursor, err := coll.Aggregate(context.TODO(), mongo.Pipeline{matchStage, unsetStage, sortStage, limitStage})
 		if err != nil {
 			panic(err)
 		}
 
-		var results []bson.M
+		var results []Tea
 		if err = cursor.All(context.TODO(), &results); err != nil {
 			panic(err)
 		}
 		for _, result := range results {
-			fmt.Printf("Tea: %v \nToppings: %v \nPrice: $%v \n\n", result["type"], result["toppings"], result["price"])
+			fmt.Printf("Tea: %v \nToppings: %v \nPrice: $%v \n\n", result.Type, strings.Join(result.Toppings, ", "), result.Price)
 		}
 	}
 }