geospatial updates and removed reference to index v1 properties

jcocchi · jcocchi · commit 123180c52de4 · 2022-10-21T17:32:10.000-07:00
diff --git a/articles/cosmos-db/index-overview.md b/articles/cosmos-db/index-overview.md
@@ -147,7 +147,7 @@ Range indexes can be used on scalar values (string or number). The default index
    SELECT * FROM c WHERE ST_INTERSECTS(c.property, { 'type':'Polygon', 'coordinates': [[ [31.8, -5], [32, -5], [31.8, -5] ]]  })  
    ```
 
-Spatial indexes can be used on correctly formatted [GeoJSON](./sql-query-geospatial-intro.md) objects. Points, LineStrings, Polygons, and MultiPolygons are currently supported. To use this index type, set by using the `"kind": "Range"` property when configuring the indexing policy. To learn how to configure spatial indexes, see [Spatial indexing policy examples](how-to-manage-indexing-policy.md#spatial-index)
+Spatial indexes can be used on correctly formatted [GeoJSON](./sql-query-geospatial-intro.md) objects. Points, LineStrings, Polygons, and MultiPolygons are currently supported. To learn how to configure spatial indexes, see [Spatial indexing policy examples](how-to-manage-indexing-policy.md#spatial-index)
 
 ### Composite indexes
 
diff --git a/articles/cosmos-db/index-policy.md b/articles/cosmos-db/index-policy.md
@@ -335,7 +335,7 @@ A container's indexing policy can be updated at any time [by using the Azure por
 > Index transformation is an operation that consumes [Request Units](request-units.md). Request Units consumed by an index transformation aren't currently billed if you are using [serverless](serverless.md) containers. These Request Units will get billed once serverless becomes generally available.
 
 > [!NOTE]
-> You can track the progress of index transformation in the Azure portal or [by using one of the SDKs](how-to-manage-indexing-policy.md).
+> You can track the progress of index transformation in the [Azure portal](how-to-manage-indexing-policy.md#use-the-azure-portal) or by [using one of the SDKs](how-to-manage-indexing-policy.md#dotnet-sdk).
 
 There's no impact to write availability during any index transformations. The index transformation uses your provisioned RUs but at a lower priority than your CRUD operations or queries.
 
diff --git a/articles/cosmos-db/nosql/how-to-manage-indexing-policy.md b/articles/cosmos-db/nosql/how-to-manage-indexing-policy.md
@@ -44,40 +44,6 @@ Here are some examples of indexing policies shown in [their JSON format](../inde
     }
 ```
 
-This indexing policy is equivalent to the one below which manually sets ```kind```, ```dataType```, and ```precision``` to their default values. These properties are no longer necessary to explicitly set and you should omit them from your indexing policy entirely (as shown in above example). If you try to set these properties, they'll be automatically removed from your indexing policy.
-
-
-```json
-    {
-        "indexingMode": "consistent",
-        "includedPaths": [
-            {
-                "path": "/*",
-                "indexes": [
-                    {
-                        "kind": "Range",
-                        "dataType": "Number",
-                        "precision": -1
-                    },
-                    {
-                        "kind": "Range",
-                        "dataType": "String",
-                        "precision": -1
-                    }
-                ]
-            }
-        ],
-        "excludedPaths": [
-            {
-                "path": "/path/to/single/excluded/property/?"
-            },
-            {
-                "path": "/path/to/root/of/multiple/excluded/properties/*"
-            }
-        ]
-    }
-```
-
 ### Opt-in policy to selectively include some property paths
 
 ```json
@@ -99,48 +65,6 @@ This indexing policy is equivalent to the one below which manually sets ```kind`
     }
 ```
 
-This indexing policy is equivalent to the one below which manually sets ```kind```, ```dataType```, and ```precision``` to their default values. These properties are no longer necessary to explicitly set and you should omit them from your indexing policy entirely (as shown in above example). If you try to set these properties, they'll be automatically removed from your indexing policy.
-
-
-```json
-    {
-        "indexingMode": "consistent",
-        "includedPaths": [
-            {
-                "path": "/path/to/included/property/?",
-                "indexes": [
-                    {
-                        "kind": "Range",
-                        "dataType": "Number"
-                    },
-                    {
-                        "kind": "Range",
-                        "dataType": "String"
-                    }
-                ]
-            },
-            {
-                "path": "/path/to/root/of/multiple/included/properties/*",
-                "indexes": [
-                    {
-                        "kind": "Range",
-                        "dataType": "Number"
-                    },
-                    {
-                        "kind": "Range",
-                        "dataType": "String"
-                    }
-                ]
-            }
-        ],
-        "excludedPaths": [
-            {
-                "path": "/*"
-            }
-        ]
-    }
-```
-
 > [!NOTE]
 > It is generally recommended to use an **opt-out** indexing policy to let Azure Cosmos DB proactively index any new property that may be added to your data model.
 
@@ -377,36 +301,6 @@ To create a container with a custom indexing policy see, [Create a container wit
 
 ## <a id="dotnet-sdk"></a> Use the .NET SDK
 
-# [.NET SDK V2](#tab/dotnetv2)
-
-The `DocumentCollection` object from the [.NET SDK v2](https://www.nuget.org/packages/Microsoft.Azure.DocumentDB/) exposes an `IndexingPolicy` property that lets you change the `IndexingMode` and add or remove `IncludedPaths` and `ExcludedPaths`.
-
-```csharp
-// Retrieve the container's details
-ResourceResponse<DocumentCollection> containerResponse = await client.ReadDocumentCollectionAsync(UriFactory.CreateDocumentCollectionUri("database", "container"));
-// Set the indexing mode to consistent
-containerResponse.Resource.IndexingPolicy.IndexingMode = IndexingMode.Consistent;
-// Add an included path
-containerResponse.Resource.IndexingPolicy.IncludedPaths.Add(new IncludedPath { Path = "/*" });
-// Add an excluded path
-containerResponse.Resource.IndexingPolicy.ExcludedPaths.Add(new ExcludedPath { Path = "/name/*" });
-// Add a spatial index
-containerResponse.Resource.IndexingPolicy.SpatialIndexes.Add(new SpatialSpec() { Path = "/locations/*", SpatialTypes = new Collection<SpatialType>() { SpatialType.Point } } );
-// Add a composite index
-containerResponse.Resource.IndexingPolicy.CompositeIndexes.Add(new Collection<CompositePath> {new CompositePath() { Path = "/name", Order = CompositePathSortOrder.Ascending }, new CompositePath() { Path = "/age", Order = CompositePathSortOrder.Descending }});
-// Update container with changes
-await client.ReplaceDocumentCollectionAsync(containerResponse.Resource);
-```
-
-To track the index transformation progress, pass a `RequestOptions` object that sets the `PopulateQuotaInfo` property to `true`.
-
-```csharp
-// retrieve the container's details
-ResourceResponse<DocumentCollection> container = await client.ReadDocumentCollectionAsync(UriFactory.CreateDocumentCollectionUri("database", "container"), new RequestOptions { PopulateQuotaInfo = true });
-// retrieve the index transformation progress from the result
-long indexTransformationProgress = container.IndexTransformationProgress;
-```
-
 # [.NET SDK V3](#tab/dotnetv3)
 
 The `ContainerProperties` object from the [.NET SDK v3](https://www.nuget.org/packages/Microsoft.Azure.Cosmos/) (see [this Quickstart](quickstart-dotnet.md) regarding its usage) exposes an `IndexingPolicy` property that lets you change the `IndexingMode` and add or remove `IncludedPaths` and `ExcludedPaths`.
@@ -463,6 +357,36 @@ await client.GetDatabase("database").DefineContainer(name: "container", partitio
     .Attach()
     .CreateIfNotExistsAsync();
 ```
+
+# [.NET SDK V2](#tab/dotnetv2)
+
+The `DocumentCollection` object from the [.NET SDK v2](https://www.nuget.org/packages/Microsoft.Azure.DocumentDB/) exposes an `IndexingPolicy` property that lets you change the `IndexingMode` and add or remove `IncludedPaths` and `ExcludedPaths`.
+
+```csharp
+// Retrieve the container's details
+ResourceResponse<DocumentCollection> containerResponse = await client.ReadDocumentCollectionAsync(UriFactory.CreateDocumentCollectionUri("database", "container"));
+// Set the indexing mode to consistent
+containerResponse.Resource.IndexingPolicy.IndexingMode = IndexingMode.Consistent;
+// Add an included path
+containerResponse.Resource.IndexingPolicy.IncludedPaths.Add(new IncludedPath { Path = "/*" });
+// Add an excluded path
+containerResponse.Resource.IndexingPolicy.ExcludedPaths.Add(new ExcludedPath { Path = "/name/*" });
+// Add a spatial index
+containerResponse.Resource.IndexingPolicy.SpatialIndexes.Add(new SpatialSpec() { Path = "/locations/*", SpatialTypes = new Collection<SpatialType>() { SpatialType.Point } } );
+// Add a composite index
+containerResponse.Resource.IndexingPolicy.CompositeIndexes.Add(new Collection<CompositePath> {new CompositePath() { Path = "/name", Order = CompositePathSortOrder.Ascending }, new CompositePath() { Path = "/age", Order = CompositePathSortOrder.Descending }});
+// Update container with changes
+await client.ReplaceDocumentCollectionAsync(containerResponse.Resource);
+```
+
+To track the index transformation progress, pass a `RequestOptions` object that sets the `PopulateQuotaInfo` property to `true`.
+
+```csharp
+// retrieve the container's details
+ResourceResponse<DocumentCollection> container = await client.ReadDocumentCollectionAsync(UriFactory.CreateDocumentCollectionUri("database", "container"), new RequestOptions { PopulateQuotaInfo = true });
+// retrieve the index transformation progress from the result
+long indexTransformationProgress = container.IndexTransformationProgress;
+```
 ---
 
 ## Use the Java SDK
diff --git a/articles/cosmos-db/nosql/media/how-to-manage-indexing-policy/indexing-policy-portal.png b/articles/cosmos-db/nosql/media/how-to-manage-indexing-policy/indexing-policy-portal.png
diff --git a/articles/cosmos-db/nosql/query/geospatial-intro.md b/articles/cosmos-db/nosql/query/geospatial-intro.md
@@ -101,11 +101,13 @@ Azure Cosmos DB interprets coordinates as represented per the WGS-84 reference s
 **LineStrings in GeoJSON**
 
 ```json
+{
     "type":"LineString",
-    "coordinates":[ [
+    "coordinates":[
         [ 31.8, -5 ],
         [ 31.8, -4.7 ]
-    ] ]
+    ]
+}
 ```
 
 ### Polygons
diff --git a/articles/cosmos-db/nosql/query/spatial-functions.md b/articles/cosmos-db/nosql/query/spatial-functions.md
@@ -18,17 +18,13 @@ Azure Cosmos DB supports the following Open Geospatial Consortium (OGC) built-in
 
 The following scalar functions perform an operation on a spatial object input value and return a numeric or Boolean value.  
 
+* [ST_AREA](st-area.md)
 * [ST_DISTANCE](st-distance.md)
 * [ST_INTERSECTS](st-intersects.md)
 * [ST_ISVALID](st-isvalid.md)
 * [ST_ISVALIDDETAILED](st-isvaliddetailed.md)
 * [ST_WITHIN](st-within.md)
 
-
-
-
-  
-
 ## Next steps
 
 - [System functions Azure Cosmos DB](system-functions.md)
diff --git a/articles/cosmos-db/nosql/query/st-area.md b/articles/cosmos-db/nosql/query/st-area.md
@@ -0,0 +1,72 @@
+---
+title: ST_AREA in Azure Cosmos DB query language
+description: Learn about SQL system function ST_AREA in Azure Cosmos DB.
+author: jcocchi
+ms.service: cosmos-db
+ms.subservice: nosql
+ms.topic: conceptual
+ms.date: 10/21/2022
+ms.author: jucocchi
+ms.custom: query-reference, ignite-2022
+---
+
+# ST_AREA (Azure Cosmos DB)
+
+[!INCLUDE[NoSQL](../../includes/appliesto-nosql.md)]
+
+ Returns the total area of a GeoJSON Polygon or MultiPolygon expression. To learn more, see the [Geospatial and GeoJSON location data](geospatial-intro.md) article.
+  
+## Syntax
+  
+```sql
+ST_AREA (<spatial_expr>)
+```
+  
+## Arguments
+  
+*spatial_expr*  
+   Is any valid GeoJSON Polygon or MultiPolygon object expression.
+  
+## Return types
+  
+  Returns the total area of a set of points. This is expressed in square meters for the default reference system.
+  
+## Examples
+  
+  The following example shows how to return the area of a polygon using the `ST_AREA` built-in function.
+  
+```sql
+SELECT ST_AREA({
+    "type":"Polygon",
+    "coordinates":[ [
+        [ 31.8, -5 ],
+        [ 32, -5 ],
+        [ 32, -4.7 ],
+        [ 31.8, -4.7 ],
+        [ 31.8, -5 ]
+    ] ]
+}) as Area
+```
+
+Here is the result set.
+
+```json
+[
+    {
+        "Area": 735970283.0522614
+    }
+]
+```
+
+## Remarks
+
+Using the ST_AREA function to calculate the area of zero or one-dimensional figures like GeoJSON Points and LineStrings will result in an area of 0.
+
+> [!NOTE]
+> The GeoJSON specification requires that points within a Polygon be specified in counter-clockwise order. A Polygon specified in clockwise order represents the inverse of the region within it.
+
+## Next steps
+
+- [Spatial functions Azure Cosmos DB](spatial-functions.md)
+- [System functions Azure Cosmos DB](system-functions.md)
+- [Introduction to Azure Cosmos DB](../../introduction.md)
diff --git a/articles/cosmos-db/nosql/query/st-distance.md b/articles/cosmos-db/nosql/query/st-distance.md
@@ -31,7 +31,7 @@ ST_DISTANCE (<spatial_expr>, <spatial_expr>)
   
 ## Examples
   
-  The following example shows how to return all family documents that are within 30 km of the specified location using the `ST_DISTANCE` built-in function. .  
+  The following example shows how to return all family documents that are within 30 km of the specified location using the `ST_DISTANCE` built-in function. 
   
 ```sql
 SELECT f.id
