fix blocking and non-blocking issues

Author: TheovanKraay

articles/cosmos-db/TOC.yml

@@ -83,7 +83,7 @@
   - name: Concepts
     items:
     - name: NoSQL Vs relational databases
-      href: relational-or-nosql.md
+      href: relational-nosql.md
     - name: Global distribution
       items:
       - name: Overview
@@ -1057,7 +1057,7 @@
       - name: Migrate hundreds of terabytes of data into Azure Cosmos DB 
         href: migrate-cosmosdb-data.md
       - name: Migrate one-to-few relational data
-        href: migrate-relational-to-cosmosdb-sql-api.md 
+        href: migrate-relational-to-cosmos-db-sql-api.md 
     - name: Bulk executor library
       items: 
       - name: About bulk executor library

articles/cosmos-db/migrate-relational-to-cosmosdb-sql-api.md renamed to articles/cosmos-db/migrate-relational-to-cosmos-db-sql-api.md

@@ -44,7 +44,7 @@ FROM Orders o;
 
 The results of this query would look as below: 
 
-![Order Details](./media/migrate-relational-to-cosmos-sql-api/for-json-query-result.png)
+![Order Details](./media/migrate-relational-to-cosmos-sql-api/for-json-query-result.png#lightbox)
 
 
 Ideally, you want to use a single Azure Data Factory (ADF) copy activity to query SQL data as the source and write the output directly to Azure Cosmos DB sink as proper JSON objects. Currently, it is not possible to perform the needed JSON transformation in one copy activity. If we try to copy the results of the above query into an Azure Cosmos DB SQL API container, we will see the OrderDetails field as a string property of our document, instead of the expected JSON array.
@@ -60,7 +60,7 @@ We can work around this current limitation in one of the following ways:
 
 Let’s look at these approaches in more detail:
 
-## Azure Data Factory with two copy activities
+## Azure Data Factory
 
 Although we cannot embed OrderDetails as a JSON-array in the destination Cosmos DB document, we can work around the issue by using two separate Copy Activities.
 
@@ -241,7 +241,7 @@ writeConfig = {
 }
 ```
 
-Then, we will query the source Database (in this case SQL Server) for both the order and order detail records, putting the results into Spark Dataframes. We will also create a list containing all the order ids, and a Thread pool for parallel operations:
+Then, we will query the source Database (in this case SQL Server) for both the order and order detail records, putting the results into Spark Dataframes. We will also create a list containing all the order IDs, and a Thread pool for parallel operations:
 
 ```python
 import json
@@ -274,7 +274,7 @@ orderids = orders.select('OrderId').collect()
 pool = ThreadPool(10)
 ```
 
-Then, create a function for writing Orders into the target SQL API collection. This function will filter all order details for the given order id, convert them into a JSON array, and insert the array into a JSON document that we will write into the target SQL API Collection for that order:
+Then, create a function for writing Orders into the target SQL API collection. This function will filter all order details for the given order ID, convert them into a JSON array, and insert the array into a JSON document that we will write into the target SQL API Collection for that order:
 
 ```python
 def writeOrder(orderid):
@@ -322,11 +322,11 @@ def writeOrder(orderid):
   df = spark.read.json(sc.parallelize([orderjsondata]))
 
   #write the dataframe (this will be a single order record with merged many-to-one order details) to cosmos db using spark the connector
-  #https://docs.microsoft.com/en-us/azure/cosmos-db/spark-connector
+  #https://docs.microsoft.com/azure/cosmos-db/spark-connector
   df.write.format("com.microsoft.azure.cosmosdb.spark").mode("append").options(**writeConfig).save()
 ```
 
-Finally, we will call the above using a map function on the thread pool, to execute in parallel, passing in the list of order ids we created earlier:
+Finally, we will call the above using a map function on the thread pool, to execute in parallel, passing in the list of order IDs we created earlier:
 
 ```python
 #map order details to orders in parallel using the above function

articles/cosmos-db/relational-or-nosql.md renamed to articles/cosmos-db/relational-nosql.md

@@ -1,6 +1,6 @@
 ---
-title: Understanding the differences between NoSQL and Relational Databases 
-description: This article enumerates the differences between NoSQL and Relational Databases 
+title: Understanding the differences between Azure Cosmos DB NoSQL and relational databases 
+description: This article enumerates the differences between NoSQL and relational databases 
 author: TheovanKraay
 ms.author: thvankra
 ms.service: cosmos-db
@@ -27,7 +27,7 @@ If your transactional volumes are reaching extreme levels, such as many thousand
 
 ![Backend](./media/relational-or-nosql/backend-scaled.png)
 
-## Hierarchical Data
+## Hierarchical data
 
 There are a significant number of use cases where transactions in the database can contain many parent-child relationships. These relationships can grow significantly over time, and prove difficult to manage. Forms of [hierarchical databases](https://en.wikipedia.org/wiki/Hierarchical_database_model) did emerge during the 1980s, but were not popular due to inefficiency in storage. They also lost traction as [Ted Codd’s relational model](https://en.wikipedia.org/wiki/Relational_model) became the de facto standard used by virtually all mainstream database management systems.
 
@@ -37,7 +37,7 @@ The emergence of [object oriented design](https://en.wikipedia.org/wiki/Object-o
 
 ![OrderDetails](./media/relational-or-nosql/order-orderdetails.jpg)
 
-## Complex Networks and Relationships
+## Complex networks and relationships
 
 Ironically, given their name, relational databases present a less than optimal solution for modeling deep and complex relationships. The reason for this is that relationships between entities do not actually exist in a relational database. They need to be computed at runtime, with complex relationships requiring cartesian joins in order to allow mapping using queries. As a result, operations become exponentially more expensive in terms of computation as relationships increase. In some cases, a relational database attempting to manage such entities will become unusable.
 
@@ -63,7 +63,7 @@ The [microservices](https://en.wikipedia.org/wiki/Microservices) pattern has gro
 * a JavaScript engine and [query API](https://docs.microsoft.com/azure/cosmos-db/javascript-query-api) built into the database.
 * a state-of-the-art [change feed](https://docs.microsoft.com/azure/cosmos-db/change-feed) which clients can subscribe to in order to get notified of modifications to a container.
 
-## Some challenges with NoSQL Databases
+## Some challenges with NoSQL databases
 
 Although there are some clear advantages when implementing NoSQL databases, there are also some challenges that you may want to take into consideration. These may not be present to the same degree when working with the relational model: