Merging changes synced from https://github.com/MicrosoftDocs/sql-docs-pr (branch live)

Author: fenxu

docs/relational-databases/collations/collation-and-unicode-support.md

@@ -52,7 +52,7 @@ A collation specifies the bit patterns that represent each character in a data s
 
 [!INCLUDE[tsql](../../includes/tsql-md.md)] statement results can vary when the statement is run in the context of different databases that have different collation settings. If it is possible, use a standardized collation for your organization. This way, you do not have to explicitly specify the collation in every character or Unicode expression. If you must work with objects that have different collation and code page settings, code your queries to consider the rules of collation precedence. For more information, see [Collation Precedence (Transact-SQL)](../../t-sql/statements/collation-precedence-transact-sql.md).    
 
-The options associated with a collation are case sensitivity, accent sensitivity, Kana-sensitivity, width sensitivity, variation-selector-sensitivity. [!INCLUDE[sql-server-2019](../../includes/sssqlv15-md.md)] introduces an additional option for UTF-8 encoding. These options are specified by appending them to the collation name. For example, this collation `Japanese_Bushu_Kakusu_100_CS_AS_KS_WS_UTF8` is case-sensitive, accent-sensitive, Kana-sensitive, width-sensitive, and UTF-8 encoded. As another example, this collation `Japanese_Bushu_Kakusu_140_CI_AI_KS_WS_VSS` is case-insensitive, accent-insensitive, Kana-sensitive, width-sensitive, variation-selector-sensitive and uses non-Unicode encoding. The following table describes the behavior associated with these various options.    
+The options associated with a collation are case sensitivity, accent sensitivity, Kana-sensitivity, width sensitivity, variation-selector-sensitivity. [!INCLUDE[sql-server-2019](../../includes/sssqlv15-md.md)] introduces an additional option for [UTF-8](http://www.wikipedia.org/wiki/UTF-8) encoding. These options are specified by appending them to the collation name. For example, this collation `Japanese_Bushu_Kakusu_100_CS_AS_KS_WS_UTF8` is case-sensitive, accent-sensitive, Kana-sensitive, width-sensitive, and UTF-8 encoded. As another example, this collation `Japanese_Bushu_Kakusu_140_CI_AI_KS_WS_VSS` is case-insensitive, accent-insensitive, Kana-sensitive, width-sensitive, variation-selector-sensitive and uses non-Unicode encoding. The following table describes the behavior associated with these various options.    
 
 |Option|Description|    
 |------------|-----------------|    

docs/relational-databases/in-memory-oltp/altering-memory-optimized-tables.md

@@ -1,7 +1,7 @@
 ---
 title: "Altering Memory-Optimized Tables | Microsoft Docs"
 ms.custom: ""
-ms.date: "06/19/2017"
+ms.date: "10/22/2018"
 ms.prod: sql
 ms.prod_service: "database-engine, sql-database"
 ms.reviewer: ""
@@ -14,36 +14,42 @@ manager: craigg
 monikerRange: "=azuresqldb-current||>=sql-server-2016||=sqlallproducts-allversions||>=sql-server-linux-2017||=azuresqldb-mi-current"
 ---
 # Altering Memory-Optimized Tables
+
 [!INCLUDE[appliesto-ss-asdb-xxxx-xxx-md](../../includes/appliesto-ss-asdb-xxxx-xxx-md.md)]
 
-  Schema and index changes on memory-optimized tables can be performed by using the ALTER TABLE statement. In SQL Server 2016 and Azure SQL Database ALTER TABLE operations on memory-optimized tables are OFFLINE, meaning that the table is not available for querying while the operation is in progress. The database application can continue to run, and any operation that is accessing the table is blocked until the alteration process is completed. It is possible to combine multiple ADD, DROP or ALTER operations in a single ALTER TABLE statement.
+Schema and index changes on memory-optimized tables can be performed by using the ALTER TABLE statement. In SQL Server 2016 and Azure SQL Database ALTER TABLE operations on memory-optimized tables are OFFLINE, meaning that the table is not available for querying while the operation is in progress. The database application can continue to run, and any operation that is accessing the table is blocked until the alteration process is completed. It is possible to combine multiple ADD, DROP or ALTER operations in a single ALTER TABLE statement.
+
+> [!IMPORTANT]
+> Azure SQL Database Managed Instance does not support memory-optimized tables.
   
 ## ALTER TABLE  
- 
+
 The ALTER TABLE syntax is used for making changes to the table schema, as well as for adding, deleting, and rebuilding indexes. Indexes are considered part of the table definition:  
 
--   The syntax ALTER TABLE ... ADD/DROP/ALTER INDEX is supported only for memory-optimized tables.  
+- The syntax ALTER TABLE ... ADD/DROP/ALTER INDEX is supported only for memory-optimized tables.  
 
--   Without using an ALTER TABLE statement, the statements CREATE INDEX and DROP INDEX and ALTER INDEX are *not* supported for indexes on memory-optimized tables.  
+- Without using an ALTER TABLE statement, the statements [CREATE INDEX](../../t-sql/statements/create-index-transact-sql.md), [DROP INDEX](../../t-sql/statements/drop-index-transact-sql.md), [ALTER INDEX](../../t-sql/statements/alter-index-transact-sql.md), and [PAD_INDEX](../../t-sql/statements/alter-table-index-option-transact-sql.md) are not supported for indexes on memory-optimized tables.  
 
 The following types of alterations are supported:  
 
--   Changing the bucket count  
+- Changing the bucket count  
 
--   Adding and removing an index  
+- Adding and removing an index  
 
--   Changing, adding and removing a column  
+- Changing, adding and removing a column  
 
--   Adding and removing a constraint  
+- Adding and removing a constraint  
 
  For more information on ALTER TABLE functionality and the complete syntax, see [ALTER TABLE (Transact-SQL)](../../t-sql/statements/alter-table-transact-sql.md)  
 
-## Schema-bound Dependency  
+## Schema-bound Dependency
+
  Natively compiled stored procedures are required to be schema-bound, meaning they have a schema-bound dependency on the memory optimized tables they access, and the columns they reference. A schema-bound dependency is a relationship between two entities that prevents the referenced entity from being dropped or incompatibly modified as long as the referencing entity exists.  
 
  For example, if a schema-bound natively compiled stored procedure references a column *c1* from table *mytable*, column *c1* cannot be dropped. Similarly, if there is such a procedure with an INSERT statement without column list (e.g., `INSERT INTO dbo.mytable VALUES (...)`), then no column in the table can be dropped.  
- 
+
 ## Logging of ALTER TABLE on memory-optimized tables
+
 On a memory-optimized table, most ALTER TABLE scenarios now run in parallel and result in an optimization of writes to the transaction log. The optimization is achieved by only logging the metadata changes to the transaction log. However, the following ALTER TABLE operations run single-threaded and are not log-optimized.
 
 The single-threaded operation in this case would log the entire content of the altered table to the transaction log. A list of single-threaded operations follows:
@@ -54,68 +60,66 @@ The single-threaded operation in this case would log the entire content of the a
 
 - Almost anything that affects an [off-row column](../../relational-databases/in-memory-oltp/supported-data-types-for-in-memory-oltp.md).
 
-    - Cause an on-row column to move off-row.
-
-    - Cause an off-row column to move on-row.
+  - Cause an on-row column to move off-row.
+  - Cause an off-row column to move on-row.
+  - Create a new off-row column.
+  - *Exception:* Lengthening an already off-row column is logged in the optimized way.
+  
+## Examples
 
-    - Create a new off-row column.
+The following example alters the bucket count of an existing hash index. This rebuilds the hash index with the new bucket count while other properties of the hash index remain the same.  
 
-    - *Exception:* Lengthening an already off-row column is logged in the optimized way. 
-  
-## Examples  
- The following example alters the bucket count of an existing hash index. This rebuilds the hash index with the new bucket count while other properties of the hash index remain the same.  
-  
 ```sql
-ALTER TABLE Sales.SalesOrderDetail_inmem   
+ALTER TABLE Sales.SalesOrderDetail_inmem
        ALTER INDEX imPK_SalesOrderDetail_SalesOrderID_SalesOrderDetailID  
               REBUILD WITH (BUCKET_COUNT=67108864);  
 GO
 ```
-  
- The following example adds a column with a NOT NULL constraint and with a DEFAULT definition, and uses WITH VALUES to provide values for each existing row in the table. If WITH VALUES is not used, each row has the value NULL in the new column.  
-  
-```sql  
+
+The following example adds a column with a NOT NULL constraint and with a DEFAULT definition, and uses WITH VALUES to provide values for each existing row in the table. If WITH VALUES is not used, each row has the value NULL in the new column.  
+
+```sql
 ALTER TABLE Sales.SalesOrderDetail_inmem  
        ADD Comment NVARCHAR(100) NOT NULL DEFAULT N'' WITH VALUES;  
 GO
-```  
-  
- The following example adds a primary key constraint to an existing column.  
-  
+```
+
+The following example adds a primary key constraint to an existing column.  
+
 ```sql
-CREATE TABLE dbo.UserSession (   
-   SessionId int not null,   
-   UserId int not null,   
-   CreatedDate datetime2 not null,   
-   ShoppingCartId int,   
-   index ix_UserId nonclustered hash (UserId) with (bucket_count=400000)   
-)   
+CREATE TABLE dbo.UserSession (
+   SessionId int not null,
+   UserId int not null,
+   CreatedDate datetime2 not null,
+   ShoppingCartId int,
+   index ix_UserId nonclustered hash (UserId) with (bucket_count=400000)
+)
 WITH (MEMORY_OPTIMIZED=ON, DURABILITY=SCHEMA_ONLY) ;  
 GO  
 
 ALTER TABLE dbo.UserSession  
        ADD CONSTRAINT PK_UserSession PRIMARY KEY NONCLUSTERED (SessionId);  
 GO
-```  
-  
- The following example removes an index.  
-  
+```
+
+The following example removes an index.  
+
 ```sql
 ALTER TABLE Sales.SalesOrderDetail_inmem  
        DROP INDEX ix_ModifiedDate;  
 GO
 ```  
-  
- The following example adds an index.  
-  
+
+The following example adds an index.  
+
 ```sql  
 ALTER TABLE Sales.SalesOrderDetail_inmem  
        ADD INDEX ix_ModifiedDate (ModifiedDate);  
 GO  
 ```  
-  
- The following example adds multiple columns, with an index and constraints.  
-  
+
+The following example adds multiple columns, with an index and constraints.  
+
 ```sql
 ALTER TABLE Sales.SalesOrderDetail_inmem  
        ADD    CustomerID int NOT NULL DEFAULT -1 WITH VALUES,  
@@ -124,12 +128,8 @@ ALTER TABLE Sales.SalesOrderDetail_inmem
 GO  
 ```
 
-
 <a name="logging-of-alter-table-on-memory-optimized-tables-124"></a>
 
-
 ## See Also  
 
 [Memory-Optimized Tables](../../relational-databases/in-memory-oltp/memory-optimized-tables.md)  
-  
-

docs/t-sql/functions/nchar-transact-sql.md

@@ -36,9 +36,9 @@ NCHAR ( integer_expression )
 
 ## Arguments  
  *integer_expression*  
- When the collation of the database does not contain the supplementary character (SC) flag, this is a positive whole number from 0 through 65535 (0 through 0xFFFF). If a value outside this range is specified, NULL is returned. For more information about supplementary characters, see [Collation and Unicode Support](../../relational-databases/collations/collation-and-unicode-support.md).  
+ When the collation of the database does not contain the [Supplementary Character (SC)](../../relational-databases/collations/collation-and-unicode-support.md#Supplementary_Characters) flag, this is a positive integer from 0 through 65535 (0 through 0xFFFF). If a value outside this range is specified, NULL is returned. For more information about supplementary characters, see [Collation and Unicode Support](../../relational-databases/collations/collation-and-unicode-support.md).  
 
- When the collation of the database supports the supplementary character (SC) flag, this is a positive whole number from 0 through 1114111 (0 through 0x10FFFF). If a value outside this range is specified, NULL is returned.  
+ When the collation of the database supports the SC flag, this is a positive integer from 0 through 1114111 (0 through 0x10FFFF). If a value outside this range is specified, NULL is returned.  
 
 ## Return Types  
  **nchar(1)** when the default database collation does not support supplementary characters.  
@@ -47,7 +47,7 @@ NCHAR ( integer_expression )
 
  If the parameter *integer_expression* lies in the range 0 - 0xFFFF, only one character is returned. For higher values, NCHAR returns the corresponding surrogate pair. Do not construct a surrogate pair by using `NCHAR(<High surrogate>) + NCHAR(\<Low Surrogate>)`. Instead, use a database collation that supports supplementary characters and then specify the Unicode codepoint for the surrogate pair. The following example demonstrates both the old style method of constructing a surrogate pair and the preferred method of specifying the Unicode codepoint.  
 
-```  
+```sql  
 CREATE DATABASE test COLLATE Finnish_Swedish_100_CS_AS_SC;  
 DECLARE @d nvarchar(10) = N'𣅿';
 -- Old style method.  
@@ -65,7 +65,7 @@ SELECT NCHAR(UNICODE(@d));
 ### A. Using NCHAR and UNICODE  
  The following example uses the `UNICODE` and `NCHAR` functions to print the `UNICODE` value and the `NCHAR` (Unicode character) of the second character of the `København` character string, and to print the actual second character, `ø`.  
 
-```  
+```sql  
 DECLARE @nstring nchar(8);  
 SET @nstring = N'København';  
 SELECT UNICODE(SUBSTRING(@nstring, 2, 1)),   
@@ -84,7 +84,7 @@ GO
 ### B. Using SUBSTRING, UNICODE, CONVERT, and NCHAR  
  The following example uses the `SUBSTRING`, `UNICODE`, `CONVERT`, and `NCHAR` functions to print the character number, the Unicode character, and the UNICODE value of each character in the string `København`.  
 
-```  
+```sql  
 -- The @position variable holds the position of the character currently  
 -- being processed. The @nstring variable is the Unicode character   
 -- string to process.  

docs/t-sql/functions/unicode-transact-sql.md

@@ -43,14 +43,14 @@ UNICODE ( 'ncharacter_expression' )
  **int**  
 
 ## Remarks  
- In versions of [!INCLUDE[ssNoVersion](../../includes/ssnoversion-md.md)] earlier than [!INCLUDE[ssSQL11](../../includes/sssql11-md.md)] and in [!INCLUDE[ssSDSfull](../../includes/sssdsfull-md.md)], the UNICODE function returns a UCS-2 codepoint in the range 0 through 0xFFFF. In [!INCLUDE[ssSQL11](../../includes/sssql11-md.md)] and later editions, when using SC collations, UNICODE returns a UTF-16 codepoint in the range 0 through 0x10FFFF.  
+ In versions of [!INCLUDE[ssNoVersion](../../includes/ssnoversion-md.md)] earlier than [!INCLUDE[ssSQL11](../../includes/sssql11-md.md)] and in [!INCLUDE[ssSDSfull](../../includes/sssdsfull-md.md)], the UNICODE function returns a UCS-2 codepoint in the range 0 through 0xFFFF. Starting with [!INCLUDE[ssSQL11](../../includes/sssql11-md.md)], when using [Supplementary Character (SC)](../../relational-databases/collations/collation-and-unicode-support.md#Supplementary_Characters) enabled collations, UNICODE returns a UTF-16 codepoint in the range 0 through 0x10FFFF.  
 
 ## Examples  
 
 ### A. Using UNICODE and the NCHAR function  
  The following example uses the `UNICODE` and `NCHAR` functions to print the UNICODE value of the first character of the `Åkergatan` 24-character string, and to print the actual first character, `Å`.  
 
-```  
+```sql  
 DECLARE @nstring nchar(12);  
 SET @nstring = N'Åkergatan 24';  
 SELECT UNICODE(@nstring), NCHAR(UNICODE(@nstring));  
@@ -66,7 +66,7 @@ SELECT UNICODE(@nstring), NCHAR(UNICODE(@nstring));
 ### B. Using SUBSTRING, UNICODE, and CONVERT  
  The following example uses the `SUBSTRING`, `UNICODE`, and `CONVERT` functions to print the character number, the Unicode character, and the UNICODE value of each of the characters in the string `Åkergatan 24`.  
 
-```  
+```sql  
 -- The @position variable holds the position of the character currently  
 -- being processed. The @nstring variable is the Unicode character   
 -- string to process.