fixing the TOC

Author: AvijitkGupta

articles/cosmos-db/mongodb/vcore/TOC.yml

@@ -88,6 +88,8 @@
           href: how-to-create-wildcard-indexes.md
         - name: Search and query text
           href: how-to-create-text-index.md
+        - name: Optimize index creation
+          href: how-to-create-indexes.md
     - name: Scale cluster
       href: how-to-scale-cluster.md
     - name: Restore cluster
@@ -98,10 +100,6 @@
       href: how-to-monitor-diagnostics-logs.md
     - name: Use Azure Private Link
       href: how-to-private-link.md
-    - name: Optimize index creation
-      href: how-to-create-indexes.md
-    - name: Create wildcard indexes
-      href: how-to-create-wildcard-indexes.md
 - name: Reference
   items:
     - name: Release notes

articles/cosmos-db/mongodb/vcore/indexing-basics.md

@@ -41,7 +41,7 @@ This example application stores articles as documents with the following structu
 }
 ```
 
-### Single field indexes
+## Single field indexes
 
 Single field indexes store information from a single field in a collection. The sort order of the single field index doesn't matter. _id field remains indexed by default.
 
@@ -54,31 +54,37 @@ MongoDB vcore supports creating index at following
 The following command creates a single field index on the field `author` and the following command creates it on an embedded field `firstName`.
 
 ```javascript
-db.coll.createIndex({"author": 1})
+use cosmicworks
+
+db.products.createIndex({"author": 1})
 
 // indexing embedded property
-db.coll.createIndex({"author.firstName": -1})
+db.products.createIndex({"author.firstName": -1})
 ```
 
 One query can use multiple single field indexes where available.
 
 > [!NOTE]
 > Azure Cosmos DB for MongoDB vcore allows creating maximum of 64 indexes on a collection.
 
-### Compound indexes
+## Compound indexes
 
 Compound indexes are required if your query needs the ability to **query or sort** data from two or more fields in each document in a collection.
 
 The following command creates a compound index on the fields `author` and `launchDate` in opposite sort order.
 
 ```javascript
-db.coll.createIndex({"author":1, "launchDate":-1})
+use cosmicworks
+
+db.products.createIndex({"author":1, "launchDate":-1})
 ```
 
 `Order` of columns affect the selectivity or utilization of index. The `find` query wouldn't utilize the index created.
 
 ```javascript
-db.coll.find({"launchDate": {$gt: ISODate("2024-06-01T00:00:00.000Z")}})
+use cosmicworks
+
+db.products.find({"launchDate": {$gt: ISODate("2024-06-01T00:00:00.000Z")}})
 ```
 
 Compounded indexes on nested fields aren't supported by default due to limitations with arrays. If your nested field doesn't contain an array, the index works as intended. If your nested field contains an array (anywhere on the path), that value is ignored in the index.
@@ -112,12 +118,14 @@ Compound index provides support for
 - Maximum of 32 columns within a compound index.
 - Indexing nested properties.
 
-### Partial indexes
+## Partial indexes
 
 Indexes that have an associated query filter that describes when to generate a term in the index.
 
 ```javascript
-db.coll.createIndex (
+use cosmicworks
+
+db.products.createIndex (
    { "author": 1, "launchDate": 1 },
    { partialFilterExpression: { "launchDate": { $gt: ISODate("2024-06-24T10:08:20.000Z") } } }
 )
@@ -127,7 +135,7 @@ db.coll.createIndex (
 
 - Partial indexes don't support `ORDER BY` or `UNIQUE` unless the filter qualifies.
 
-### Text indexes
+## Text indexes
 
 Text indexes are special data structures that optimize text-based queries, making them faster and more efficient.
 
@@ -142,13 +150,15 @@ db.products.createIndex({ title: "text" })
 > [!NOTE]
 > While you can define only one text index per collection, Azure Cosmos DB for MongoDB vCore allows you to create text indexes on combination of multiple fields to enable you to perform text searches across different fields in your documents.
 
-#### Configure text index options
+### Configure text index options
 
 Text indexes in Azure Cosmos DB for MongoDB vcore come with several options to customize their behavior. For example, you can specify the language for text analysis, set weights to prioritize certain fields, and configure case-insensitive searches. Here's an example of creating a text index with options:
 
 - Create an index to support search on both the `title` and `content` fields with English language support. Also, assign higher weights to the `title` field to prioritize it in search results.
 
 ```javascript
+use cosmicworks
+
 db.products.createIndex(
     { title: "text", content: "text" },
     { default_language: "english", weights: { title: 10, content: 5 }, caseSensitive: false }
@@ -158,13 +168,15 @@ db.products.createIndex(
 > [!NOTE]
 > When a client performs a text search query with the term "Cosmos DB," the score for each document in the collection will be calculated based on the presence and frequency of the term in both the "title" and "content" fields, with higher importance given to the "title" field due to its higher weight.
 
-#### Perform a text search using a text index
+### Perform a text search using a text index
 
 Once the text index is created, you can perform text searches using the "text" operator in your queries. The text operator takes a search string and matches it against the text index to find relevant documents.
 
 - Perform a text search for the phrase `Cosmos DB`.
 
 ```javascript
+use cosmicworks
+
 db.products.find(
   { $text: { $search: "Cosmos DB" } }
 )
@@ -173,6 +185,8 @@ db.products.find(
 - Optionally, use the `$meta` projection operator along with the `textScore` field in a query to see the weight
 
 ```javascript
+use cosmicworks
+
 db.products.find(
 { $text: { $search: "Cosmos DB" } },
 { score: { $meta: "textScore" } }
@@ -187,16 +201,18 @@ db.products.find(
 - Hint() isn't supported in combination with a query using $text expression.
 - Text indexes can be relatively large, consuming significant storage space compared to other index types.
 
-### WildCard indexes
+## WildCard indexes
 
 Index on single field, indexes all paths beneath the `field` , excluding other fields that are on the same level. For example, for the following sample document
 
-```javascript
-"children":
+```json
+{
+ "children":
     {
      "familyName": "Merriam",
      "pets": { "details": {“name”: "Goofy", ”age”: 3} }
    } 
+}
 ```
 
 Creating an index on { "pets.$**": 1 }, creates index on details & sub-document properties but doesn't create an index on “familyName”.
@@ -208,7 +224,7 @@ Creating an index on { "pets.$**": 1 }, creates index on details & sub-document
 - A compound wildcard index can only have 1 wildcard term and 1 or more additional index terms.
 `{ "pets.$**": 1, “familyName”: 1 }`
 
-### Geospatial indexes
+## Geospatial indexes
 
 Geospatial indexes support queries on data stored as GeoJSON objects or legacy coordinate pairs. You can use geospatial indexes to improve performance for queries on geospatial data or to run certain geospatial queries.
 
@@ -217,7 +233,7 @@ Azure Cosmos DB for MongoDB vcore provides two types of geospatial indexes:
 - 2dsphere Indexes, which support queries that interpret geometry on a sphere.
 - 2d Indexes, which support queries that interpret geometry on a flat surface.
 
-#### 2d indexes
+### 2d indexes
 
 2d indexes are supported only with legacy coordinate pair style of storing geospatial data.
 
@@ -232,7 +248,7 @@ db.places.createIndex({ "location": "2d"});
 - Only 1 location field can be part of the `2d` index and only 1 other non-geospatial field can be part of the `compound 2d` index
 `db.places.createIndex({ "location": "2d", "non-geospatial-field": 1 / -1 })`
 
-#### 2dsphere indexes
+### 2dsphere indexes
 
 `2dsphere` indexes support geospatial queries on an earth-like sphere. It can support both GeoJSON objects or legacy coordinate pairs. `2dSphere` indexes work with the GeoJSON style of storing data, if legacy points are encountered then these are converted to GeoJSON point.