Merge pull request #91532 from SnehaGunda/LandingPage2

Adding examples for index kinds

Author: ShannonLeavitt

articles/cosmos-db/index-overview.md

@@ -4,7 +4,7 @@ description: Understand how indexing works in Azure Cosmos DB.
 author: ThomasWeiss
 ms.service: cosmos-db
 ms.topic: conceptual
-ms.date: 09/10/2019
+ms.date: 10/11/2019
 ms.author: thweiss
 ---
 
@@ -59,26 +59,49 @@ When an item is written, Azure Cosmos DB effectively indexes each property's pat
 
 ## Index kinds
 
-Azure Cosmos DB currently supports three kinds of indexes:
+Azure Cosmos DB currently supports three kinds of indexes.
 
-The **range** index kind is used for:
+### Range Index
+
+**Range** index is based on an ordered tree-like structure. The range index kind is used for:
 
 - Equality queries:
 
     ```sql
    SELECT * FROM container c WHERE c.property = 'value'
    ```
 
+   ```sql
+   SELECT * FROM c WHERE c.property IN ("value1", "value2", "value3")
+   ```
+
+   Equality match on an array element
+   ```sql
+    SELECT * FROM c WHERE ARRAY_CONTAINS(c.tags, "tag1”)
+    ```
+
 - Range queries:
 
    ```sql
    SELECT * FROM container c WHERE c.property > 'value'
    ```
   (works for `>`, `<`, `>=`, `<=`, `!=`)
 
+- Checking for the presence of a property:
+
+   ```sql
+   SELECT * FROM c WHERE IS_DEFINED(c.property)
+   ```
+
+- String prefix matches (CONTAINS keyword will not leverage the range index):
+
+   ```sql
+   SELECT * FROM c WHERE STARTSWITH(c.property, "value")
+   ```
+
 - `ORDER BY` queries:
 
-   ```sql 
+   ```sql
    SELECT * FROM container c ORDER BY c.property
    ```
 
@@ -90,23 +113,33 @@ The **range** index kind is used for:
 
 Range indexes can be used on scalar values (string or number).
 
-The **spatial** index kind is used for:
+### Spatial index
+
+**Spatial** indices enable efficient queries on geospatial objects such as - points, lines, polygons, and multipolygon. These queries use ST_DISTANCE, ST_WITHIN, ST_INTERSECTS keywords. The following are some examples that use spatial index kind:
 
-- Geospatial distance queries: 
+- Geospatial distance queries:
 
    ```sql
    SELECT * FROM container c WHERE ST_DISTANCE(c.property, { "type": "Point", "coordinates": [0.0, 10.0] }) < 40
    ```
 
-- Geospatial within queries: 
+- Geospatial within queries:
 
    ```sql
    SELECT * FROM container c WHERE ST_WITHIN(c.property, {"type": "Point", "coordinates": [0.0, 10.0] } })
    ```
 
+- Geospatial intersect queries:
+
+   ```sql
+   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](geospatial.md) objects. Points, LineStrings, Polygons, and MultiPolygons are currently supported.
 
-The **composite** index kind is used for:
+### Composite indexes
+
+**Composite** indices increase the efficiency when you are performing operations on multiple fields. The composite index kind is used for:
 
 - `ORDER BY` queries on multiple properties:
 
@@ -126,6 +159,13 @@ The **composite** index kind is used for:
  SELECT * FROM container c WHERE c.property1 = 'value' AND c.property2 > 'value'
 ```
 
+As long as one filter predicate uses on of the index kind, the query engine will evaluate that first before scanning the rest. For example, if you have a SQL query such as `SELECT * FROM c WHERE c.firstName = "Andrew" and CONTAINS(c.lastName, "Liu")`
+
+* The above query will first filter for entries where firstName = "Andrew" by using the index. It then pass all of the firstName = "Andrew" entries through a subsequent pipeline to evaluate the CONTAINS filter predicate.
+
+* You can speed up queries and avoid full container scans when using functions that don’t use the index (e.g. CONTAINS) by adding additional filter predicates that do use the index. The order of filter clauses isn't important. The query engine is will figure out which predicates are more selective and run the query accordingly.
+
+
 ## Querying with indexes
 
 The paths extracted when indexing data make it easy to lookup the index when processing a query. By matching the `WHERE` clause of a query with the list of indexed paths, it is possible to identify the items that match the query predicate very quickly.