Added String Compare articles

Author: waqasm78

docs2/pages/documentations/string/string-compare-invariant-culture-ignore-case.md

@@ -0,0 +1,52 @@
+# String_CompareInvariantCultureIgnoreCase
+
+`String_CompareInvariantCultureIgnoreCase` compares two specified String objects using culture-sensitive sort rules, the invariant culture, and ignoring the case of the strings, and returns an integer that indicates their relative position in the sort order.
+
+```csharp
+String_CompareInvariantCultureIgnoreCase (
+	@strA NVARCHAR (MAX), 
+	@strB NVARCHAR (MAX)
+	)
+RETURNS INT
+```
+
+## Parameters
+
+  - **strA**: The first string to compare.
+  - **strB**: The second string to compare.
+
+## Returns
+
+A 32-bit signed integer that indicates the lexical relationship between the two comparands.
+
+| Value		| Condition	|
+|:--------- |:--------- |
+|Less than zero		|strA precedes strB in the sort order.|
+|Zero				|strA occurs in the same position as strB in the sort order.|
+|Greater than zero	|strA follows strB in the sort order.|
+
+## Example
+
+```csharp
+SELECT SQLNET::String_CompareInvariantCultureIgnoreCase('case', 'Case')
+SELECT SQLNET::String_CompareInvariantCultureIgnoreCase('encyclopædia', 'encyclopaedia')
+```
+
+# String_CompareInvariantCultureIgnoreCase4k
+
+It is equivalent to `String_CompareInvariantCultureIgnoreCase` except no NVARCHAR(MAX) parameters; it can be used when input data will never be over 4000 characters as this function offers better performance.
+
+```csharp
+String_CompareInvariantCultureIgnoreCase4k (
+	@strA NVARCHAR (4000), 
+	@strB NVARCHAR (4000)
+	)
+RETURNS INT
+```
+
+## Example
+
+```csharp
+SELECT SQLNET::String_CompareInvariantCultureIgnoreCase4k('case', 'Case')
+SELECT SQLNET::String_CompareInvariantCultureIgnoreCase4k('encyclopædia', 'encyclopaedia')
+```

docs2/pages/documentations/string/string-compare-ordinal-ignore-case.md

@@ -0,0 +1,52 @@
+# String_CompareOrdinalIgnoreCase
+
+`String_CompareOrdinalIgnoreCase` compares two specified String objects using ordinal (binary) sort rules and ignoring the case of the strings, and returns an integer that indicates their relative position in the sort order.
+
+```csharp
+String_CompareOrdinalIgnoreCase (
+	@strA NVARCHAR (MAX), 
+	@strB NVARCHAR (MAX)
+	)
+RETURNS INT
+```
+
+## Parameters
+
+  - **strA**: The first string to compare.
+  - **strB**: The second string to compare.
+
+## Returns
+
+A 32-bit signed integer that indicates the lexical relationship between the two comparands.
+
+| Value		| Condition	|
+|:--------- |:--------- |
+|Less than zero		|strA precedes strB in the sort order.|
+|Zero				|strA occurs in the same position as strB in the sort order.|
+|Greater than zero	|strA follows strB in the sort order.|
+
+## Example
+
+```csharp
+SELECT SQLNET::String_CompareOrdinalIgnoreCase('case', 'Case')
+SELECT SQLNET::String_CompareOrdinalIgnoreCase('Archæology', 'ARCHÆOLOGY')
+```
+
+# String_CompareOrdinalIgnoreCase4k
+
+It is equivalent to `String_CompareOrdinalIgnoreCase` except no NVARCHAR(MAX) parameters; it can be used when input data will never be over 4000 characters as this function offers better performance.
+
+```csharp
+String_CompareOrdinalIgnoreCase4k (
+	@strA NVARCHAR (4000), 
+	@strB NVARCHAR (4000)
+	)
+RETURNS INT
+```
+
+## Example
+
+```csharp
+SELECT SQLNET::String_CompareOrdinalIgnoreCase4k('case', 'Case')
+SELECT SQLNET::String_CompareOrdinalIgnoreCase4k('Archæology', 'ARCHÆOLOGY')
+```

docs2/pages/documentations/string/string-compare-ordinal.md

@@ -0,0 +1,52 @@
+# String_CompareOrdinal
+
+`String_CompareOrdinal` compares two specified String objects using ordinal (binary) sort rules, and returns an integer that indicates their relative position in the sort order.
+
+```csharp
+String_CompareOrdinal (
+	@strA NVARCHAR (MAX), 
+	@strB NVARCHAR (MAX)
+	)
+RETURNS INT
+```
+
+## Parameters
+
+  - **strA**: The first string to compare.
+  - **strB**: The second string to compare.
+
+## Returns
+
+A 32-bit signed integer that indicates the lexical relationship between the two comparands.
+
+| Value		| Condition	|
+|:--------- |:--------- |
+|Less than zero		|strA precedes strB in the sort order.|
+|Zero				|strA occurs in the same position as strB in the sort order.|
+|Greater than zero	|strA follows strB in the sort order.|
+
+## Example
+
+```csharp
+SELECT SQLNET::String_CompareOrdinal('case', 'Case')
+SELECT SQLNET::String_CompareOrdinal('Archæology', 'ARCHÆOLOGY')
+```
+
+# String_CompareOrdinal4k
+
+It is equivalent to `String_CompareOrdinal` except no NVARCHAR(MAX) parameters; it can be used when input data will never be over 4000 characters as this function offers better performance.
+
+```csharp
+String_CompareOrdinal4k (
+	@strA NVARCHAR (4000), 
+	@strB NVARCHAR (4000)
+	)
+RETURNS INT
+```
+
+## Example
+
+```csharp
+SELECT SQLNET::String_CompareOrdinal4k('case', 'Case')
+SELECT SQLNET::String_CompareOrdinal4k('Archæology', 'ARCHÆOLOGY')
+```

docs2/pages/documentations/string/string.md

@@ -5,8 +5,11 @@ Represents text as a sequence of UTF-16 code units.
 
 | Name | Description | Example |
 | :--- | :---------- | :------ |
-| [String_Compare](/string-compare) | Compares two specified String objects. | [Try it]()|
-| [String_CompareCurrentCulture](/string-compare-current-culture) | Compares two specified String objects using culture-sensitive sort rules and the current culture. | [Try it]()|
-| [String_CompareCurrentCultureIgnoreCase](/string-compare-current-culture-ignore-case) | Compares two specified String objects using culture-sensitive sort rules, the current culture, and ignoring the case of the strings. | [Try it]()|
-| [String_CompareIgnoreCase](/string-compare-ignore-case) | Compares two specified String objects ignoring their case. | [Try it]()|
-| [String_CompareInvariantCulture](/string-compare-invariant-culture) | Compares two specified String objects using culture-sensitive sort rules and the invariant culture. | [Try it]()|
+| [String_Compare(strA, strB)](/string-compare) | Compares two specified String objects. | [Try it]()|
+| [String_CompareCurrentCulture(strA, strB)](/string-compare-current-culture) | Compares two specified String objects using culture-sensitive sort rules and the current culture. | [Try it]()|
+| [String_CompareCurrentCultureIgnoreCase(strA, strB)](/string-compare-current-culture-ignore-case) | Compares two specified String objects using culture-sensitive sort rules, the current culture, and ignoring the case of the strings. | [Try it]()|
+| [String_CompareIgnoreCase(strA, strB)](/string-compare-ignore-case) | Compares two specified String objects ignoring their case. | [Try it]()|
+| [String_CompareInvariantCulture(strA, strB)](/string-compare-invariant-culture) | Compares two specified String objects using culture-sensitive sort rules and the invariant culture. | [Try it]()|
+| [String_CompareInvariantCultureIgnoreCase(strA, strB)](/string-compare-invariant-culture-ignore-case) | Compares two specified String objects using culture-sensitive sort rules, the invariant culture, and ignoring the case of the strings. | [Try it]()|
+| [String_CompareOrdinal(strA, strB)](/string-compare-ordinal) | Compares two specified String objects using ordinal (binary) sort rules. | [Try it]()|
+| [String_CompareOrdinalIgnoreCase(strA, strB)](/string-compare-ordinal-ignore-case) | Compares two specified String objects using ordinal (binary) sort rules, and ignoring the case of the strings. | [Try it]()|