Merge pull request #13 from waqasm78/master

Added String Compare articles

Author: JonathanMagnan

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-contains.md

@@ -0,0 +1,44 @@
+# String_Contains
+
+`String_Contains` returns a value indicating whether a specified substring occurs within this string.
+
+```csharp
+String_Contains (
+	@source NVARCHAR (MAX), 
+	@target NVARCHAR (MAX)
+	)
+RETURNS BIT
+```
+
+## Parameters
+
+  - **source**: The source string.
+  - **target**: The string to search within source string.
+
+## Returns
+
+ `true` if the target parameter occurs within the source string, or if target is the empty string (""); otherwise, `false`.
+
+## Example
+
+```csharp
+SELECT SQLNET::String_Contains('This is a string.', 'string')
+```
+
+# String_Contains4k
+
+It is equivalent to `String_Contains` 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_Contains4k (
+	@source NVARCHAR (4000), 
+	@target NVARCHAR (4000)
+	)
+RETURNS BIT
+```
+
+## Example
+
+```csharp
+SELECT SQLNET::String_Contains4k('This is a string.', 'string')
+```

docs2/pages/documentations/string/string-endswith.md

@@ -0,0 +1,44 @@
+# String_EndsWith
+
+`String_EndsWith` determines whether the end of the source string instance matches a target string.
+
+```csharp
+String_EndsWith (
+	@source NVARCHAR (MAX), 
+	@target NVARCHAR (MAX)
+	)
+RETURNS BIT
+```
+
+## Parameters
+
+  - **source**: The source string.
+  - **target**: The string to compare to the substring at the end of the source string.
+
+## Returns
+
+ `true` if the target matches the end of the source string; otherwise, `false`.
+
+## Example
+
+```csharp
+SELECT SQLNET::String_EndsWith('This is a string.', 'string.')
+```
+
+# String_EndsWith4k
+
+It is equivalent to `String_EndsWith` 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_EndsWith4k (
+	@source NVARCHAR (4000), 
+	@target NVARCHAR (4000)
+	)
+RETURNS BIT
+```
+
+## Example
+
+```csharp
+SELECT SQLNET::String_EndsWith4k('This is a string.', 'string.')
+```

docs2/pages/documentations/string/string-indexof-current-culture-ignore-case.md

@@ -0,0 +1,46 @@
+# String_IndexOfCurrentCultureIgnoreCase
+
+`String_IndexOfCurrentCultureIgnoreCase` returns the zero-based index of the first occurrence of a `searchValue` Unicode character or string within the `source` string using culture-sensitive sort rules, the current culture, and ignoring the case of the strings.
+
+```csharp
+String_IndexOfCurrentCultureIgnoreCase (
+	@source NVARCHAR (MAX), 
+	@searchValue NVARCHAR (MAX)
+	)
+RETURNS INT
+```
+
+## Parameters
+
+  - **source**: The source string.
+  - **searchValue**: The string to search within the source string.
+
+## Returns
+
+The zero-based index position of the `searchValue` parameter from the start of the `source` string if that string is found, or -1 if it is not. If `searchValue` is Empty, the return value is 0.
+
+## Example
+
+```csharp
+SELECT SQLNET::String_IndexOfCurrentCultureIgnoreCase('This is a string.', 'string')
+SELECT SQLNET::String_IndexOfCurrentCultureIgnoreCase('Archæology', 'Æ')
+```
+
+# String_IndexOfCurrentCultureIgnoreCase4k
+
+It is equivalent to `String_IndexOfCurrentCultureIgnoreCase` 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_IndexOfCurrentCultureIgnoreCase4k (
+	@source NVARCHAR (4000), 
+	@searchValue NVARCHAR (4000)
+	)
+RETURNS INT
+```
+
+## Example
+
+```csharp
+SELECT SQLNET::String_IndexOfCurrentCultureIgnoreCase4k('This is a string.', 'string')
+SELECT SQLNET::String_IndexOfCurrentCultureIgnoreCase4k('Archæology', 'Æ')
+```

docs2/pages/documentations/string/string-indexof-current-culture.md

@@ -0,0 +1,46 @@
+# String_IndexOfCurrentCulture
+
+`String_IndexOfCurrentCulture` returns the zero-based index of the first occurrence of a `searchValue` Unicode character or string within the `source` string using culture-sensitive sort rules and the current culture.
+
+```csharp
+String_IndexOfCurrentCulture (
+	@source NVARCHAR (MAX), 
+	@searchValue NVARCHAR (MAX)
+	)
+RETURNS INT
+```
+
+## Parameters
+
+  - **source**: The source string.
+  - **searchValue**: The string to search within the source string.
+
+## Returns
+
+The zero-based index position of the `searchValue` parameter from the start of the `source` string if that string is found, or -1 if it is not. If `searchValue` is Empty, the return value is 0.
+
+## Example
+
+```csharp
+SELECT SQLNET::String_IndexOfCurrentCulture('This is a string.', 'string')
+SELECT SQLNET::String_IndexOfCurrentCulture('Archæology', 'Æ')
+```
+
+# String_IndexOfCurrentCulture4k
+
+It is equivalent to `String_IndexOfCurrentCulture` 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_IndexOfCurrentCulture4k (
+	@source NVARCHAR (4000), 
+	@searchValue NVARCHAR (4000)
+	)
+RETURNS INT
+```
+
+## Example
+
+```csharp
+SELECT SQLNET::String_IndexOfCurrentCulture4k('This is a string.', 'string')
+SELECT SQLNET::String_IndexOfCurrentCulture4k('Archæology', 'Æ')
+```

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

@@ -0,0 +1,46 @@
+# String_IndexOfInvariantCultureIgnoreCase
+
+`String_IndexOfInvariantCultureIgnoreCase` returns the zero-based index of the first occurrence of a `searchValue` Unicode character or string within the `source` string using culture-sensitive sort rules, the invariant culture, and ignoring the case of the strings.
+
+```csharp
+String_IndexOfInvariantCultureIgnoreCase (
+	@source NVARCHAR (MAX), 
+	@searchValue NVARCHAR (MAX)
+	)
+RETURNS INT
+```
+
+## Parameters
+
+  - **source**: The source string.
+  - **searchValue**: The string to search within the source string.
+
+## Returns
+
+The zero-based index position of the `searchValue` parameter from the start of the `source` string if that string is found, or -1 if it is not. If `searchValue` is Empty, the return value is 0.
+
+## Example
+
+```csharp
+SELECT SQLNET::String_IndexOfInvariantCultureIgnoreCase('This is a string.', 'string')
+SELECT SQLNET::String_IndexOfInvariantCultureIgnoreCase('Archæology', 'Æ')
+```
+
+# String_IndexOfInvariantCultureIgnoreCase4k
+
+It is equivalent to `String_IndexOfInvariantCultureIgnoreCase` 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_IndexOfInvariantCultureIgnoreCase4k (
+	@source NVARCHAR (4000), 
+	@searchValue NVARCHAR (4000)
+	)
+RETURNS INT
+```
+
+## Example
+
+```csharp
+SELECT SQLNET::String_IndexOfInvariantCultureIgnoreCase4k('This is a string.', 'string')
+SELECT SQLNET::String_IndexOfInvariantCultureIgnoreCase4k('Archæology', 'Æ')
+```