ISSUES-3890 sync system functions to en document (#4168)

* ISSUES-3890 sync system functions to en document

* ISSUES-3890 fix review

* ISSUES-3890 add parseDateTimeBestEffort docs

* ISSUES-3890 fix review

* ISSUES-3890 better sql example

docs/en/query_language/functions/array_functions.md

@@ -469,4 +469,64 @@ If you want to get a list of unique items in an array, you can use arrayReduce('
 
 A special function. See the section ["ArrayJoin function"](array_join.md#functions_arrayjoin).
 
+## arrayDifference(arr)
+
+Takes an array, returns an array with the difference between all pairs of neighboring elements. For example:
+
+```sql
+SELECT arrayDifference([1, 2, 3, 4])
+```
+
+```
+┌─arrayDifference([1, 2, 3, 4])─┐
+│ [0,1,1,1]                     │
+└───────────────────────────────┘
+```
+
+## arrayDistinct(arr)
+
+Takes an array, returns an array containing the different elements in all the arrays. For example:
+
+```sql
+SELECT arrayDifference([1, 2, 3, 4])
+```
+
+```
+┌─arrayDifference([1, 2, 3, 4])─┐
+│ [0,1,1,1]                     │
+└───────────────────────────────┘
+```
+
+## arrayEnumerateDense(arr)
+
+Returns an array of the same size as the source array, indicating where each element first appears in the source array. For example: arrayEnumerateDense([10,20,10,30]) = [1,2,1,4].
+
+## arrayIntersect(arr)
+
+Takes an array, returns the intersection of all array elements. For example:
+
+```sql
+SELECT
+    arrayIntersect([1, 2], [1, 3], [2, 3]) AS no_intersect,
+    arrayIntersect([1, 2], [1, 3], [1, 4]) AS intersect
+```
+
+```
+┌─no_intersect─┬─intersect─┐
+│ []           │ [1]       │
+└──────────────┴───────────┘
+```
+
+## arrayReduce(agg_func, arr1, ...)
+
+Applies an aggregate function to array and returns its result.If aggregate function has multiple arguments, then this function can be applied to multiple arrays of the same size.
+
+arrayReduce('agg_func', arr1, ...) - apply the aggregate function `agg_func` to arrays `arr1...`. If multiple arrays passed, then elements on corresponding positions are passed as multiple arguments to the aggregate function. For example: SELECT arrayReduce('max', [1,2,3]) = 3
+
+## arrayReverse(arr)
+
+Returns an array of the same size as the source array, containing the result of inverting all elements of the source array.
+
+
+
 [Original article](https://clickhouse.yandex/docs/en/query_language/functions/array_functions/) <!--hide-->

docs/en/query_language/functions/bit_functions.md

@@ -16,5 +16,16 @@ The result type is an integer with bits equal to the maximum bits of its argumen
 
 ## bitShiftRight(a, b)
 
+## bitRotateLeft(a, b)
+
+## bitRotateRight(a, b)
+
+## bitTest(a, b)
+
+## bitTestAll(a, b)
+
+## bitTestAny(a, b)
+
+
 
 [Original article](https://clickhouse.yandex/docs/en/query_language/functions/bit_functions/) <!--hide-->

docs/en/query_language/functions/date_time_functions.md

@@ -20,17 +20,29 @@ SELECT
 
 Only time zones that differ from UTC by a whole number of hours are supported.
 
+## toTimeZone
+
+Convert time or date and time to the specified time zone.
+
 ## toYear
 
 Converts a date or date with time to a UInt16 number containing the year number (AD).
 
+## toQuarter
+
+Converts a date or date with time to a UInt8 number containing the quarter number.
+
 ## toMonth
 
 Converts a date or date with time to a UInt8 number containing the month number (1-12).
 
+## toDayOfYear
+
+Converts a date or date with time to a UInt8 number containing the number of the day of the year (1-366).
+
 ## toDayOfMonth
 
--Converts a date or date with time to a UInt8 number containing the number of the day of the month (1-31).
+Converts a date or date with time to a UInt8 number containing the number of the day of the month (1-31).
 
 ## toDayOfWeek
 
@@ -50,11 +62,20 @@ Converts a date with time to a UInt8 number containing the number of the minute
 Converts a date with time to a UInt8 number containing the number of the second in the minute (0-59).
 Leap seconds are not accounted for.
 
+## toUnixTimestamp
+
+Converts a date with time to a unix timestamp.
+
 ## toMonday
 
 Rounds down a date or date with time to the nearest Monday.
 Returns the date.
 
+## toStartOfISOYear
+
+Rounds down a date or date with time to the first day of ISO year.
+Returns the date.
+
 ## toStartOfMonth
 
 Rounds down a date or date with time to the first day of the month.
@@ -104,6 +125,10 @@ Converts a date with time to a certain fixed date, while preserving the time.
 
 Converts a date with time or date to the number of the year, starting from a certain fixed point in the past.
 
+## toRelativeQuarterNum
+
+Converts a date with time or date to the number of the quarter, starting from a certain fixed point in the past.
+
 ## toRelativeMonthNum
 
 Converts a date with time or date to the number of the month, starting from a certain fixed point in the past.
@@ -128,6 +153,14 @@ Converts a date with time or date to the number of the minute, starting from a c
 
 Converts a date with time or date to the number of the second, starting from a certain fixed point in the past.
 
+## toISOYear
+
+Converts a date or date with time to a UInt16 number containing the ISO Year number.
+
+## toISOWeek
+
+Converts a date or date with time to a UInt8 number containing the ISO Week number.
+
 ## now
 
 Accepts zero arguments and returns the current time at one of the moments of request execution.
@@ -148,6 +181,60 @@ The same as 'today() - 1'.
 Rounds the time to the half hour.
 This function is specific to Yandex.Metrica, since half an hour is the minimum amount of time for breaking a session into two sessions if a tracking tag shows a single user's consecutive pageviews that differ in time by strictly more than this amount. This means that tuples (the tag ID, user ID, and time slot) can be used to search for pageviews that are included in the corresponding session.
 
+## toYYYYMM
+
+Converts a date or date with time to a UInt32 number containing the year and month number (YYYY * 100 + MM).
+
+## toYYYYMMDD
+
+Converts a date or date with time to a UInt32 number containing the year and month number (YYYY * 10000 + MM * 100 + DD).
+
+## toYYYYMMDDhhmmss
+
+Converts a date or date with time to a UInt64 number containing the year and month number (YYYY * 10000000000 + MM * 100000000 + DD * 1000000 + hh * 10000 + mm * 100 + ss).
+
+## addYears, addMonths, addWeeks, addDays, addHours, addMinutes, addSeconds, addQuarters
+
+Function adds a Date/DateTime interval to a Date/DateTime and then return the Date/DateTime. For example:
+
+```sql
+WITH
+    toDate('2018-01-01') AS date,
+    toDateTime('2018-01-01 00:00:00') AS date_time
+SELECT
+    addYears(date, 1) AS add_years_with_date,
+    addYears(date_time, 1) AS add_years_with_date_time
+```
+
+```
+┌─add_years_with_date─┬─add_years_with_date_time─┐
+│          2019-01-01 │      2019-01-01 00:00:00 │
+└─────────────────────┴──────────────────────────┘
+```
+
+## subtractYears, subtractMonths, subtractWeeks, subtractDays, subtractHours, subtractMinutes, subtractSeconds, subtractQuarters
+
+Function subtract a Date/DateTime interval to a Date/DateTime and then return the Date/DateTime. For example:
+
+```sql
+WITH
+    toDate('2019-01-01') AS date,
+    toDateTime('2019-01-01 00:00:00') AS date_time
+SELECT
+    subtractYears(date, 1) AS subtract_years_with_date,
+    subtractYears(date_time, 1) AS subtract_years_with_date_time
+```
+
+```
+┌─subtract_years_with_date─┬─subtract_years_with_date_time─┐
+│               2018-01-01 │           2018-01-01 00:00:00 │
+└──────────────────────────┴───────────────────────────────┘
+```
+
+## dateDiff('unit', t1, t2, \[timezone\])
+
+Return the difference between two times, t1 and t2 can be Date or DateTime, If timezone is specified, it applied to both arguments. If not, timezones from datatypes t1 and t2 are used. If that timezones are not the same, the result is unspecified.
+
 ## timeSlots(StartTime, Duration,\[, Size\])
 
 For a time interval starting at 'StartTime' and continuing for 'Duration' seconds, it returns an array of moments in time, consisting of points from this interval rounded down to the 'Size' in seconds. 'Size' is an optional parameter: a constant UInt32, set to 1800 by default.

docs/en/query_language/functions/ext_dict_functions.md

@@ -21,7 +21,7 @@ If there is no `id` key in the dictionary, it returns the default value specifie
 
 ## dictGetTOrDefault {#ext_dict_functions_dictGetTOrDefault}
 
-`dictGetT('dict_name', 'attr_name', id, default)`
+`dictGetTOrDefault('dict_name', 'attr_name', id, default)`
 
 The same as the `dictGetT` functions, but the default value is taken from the function's last argument.
 

docs/en/query_language/functions/hash_functions.md

@@ -64,5 +64,52 @@ A fast, decent-quality non-cryptographic hash function for a string obtained fro
 `URLHash(s, N)` – Calculates a hash from a string up to the N level in the URL hierarchy, without one of the trailing symbols `/`,`?` or `#` at the end, if present.
 Levels are the same as in URLHierarchy. This function is specific to Yandex.Metrica.
 
+## farmHash64
+
+Calculates FarmHash64 from a string.
+Accepts a String-type argument. Returns UInt64.
+For more information, see the link: [FarmHash64](https://github.com/google/farmhash)
+
+## javaHash
+
+Calculates JavaHash from a string.
+Accepts a String-type argument. Returns Int32.
+For more information, see the link: [JavaHash](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/String.java#l1452)
+
+## hiveHash
+
+Calculates HiveHash from a string.
+Accepts a String-type argument. Returns Int32.
+Same as for [JavaHash](./hash_functions.md#javaHash), except that the return value never has a negative number.
+
+## metroHash64
+
+Calculates MetroHash from a string.
+Accepts a String-type argument. Returns UInt64.
+For more information, see the link: [MetroHash64](http://www.jandrewrogers.com/2015/05/27/metrohash/)
+
+## jumpConsistentHash
+
+Calculates JumpConsistentHash form a UInt64.
+Accepts a UInt64-type argument. Returns Int32.
+For more information, see the link: [JumpConsistentHash](https://arxiv.org/pdf/1406.2294.pdf)
+
+## murmurHash2_32, murmurHash2_64
+
+Calculates MurmurHash2 from a string.
+Accepts a String-type argument. Returns UInt64 Or UInt32.
+For more information, see the link: [MurmurHash2](https://github.com/aappleby/smhasher)
+
+## murmurHash3_32, murmurHash3_64, murmurHash3_128
+
+Calculates MurmurHash3 from a string.
+Accepts a String-type argument. Returns UInt64 Or UInt32 Or FixedString(16).
+For more information, see the link: [MurmurHash3](https://github.com/aappleby/smhasher)
+
+## xxHash32, xxHash64
+
+Calculates xxHash from a string.
+ccepts a String-type argument. Returns UInt64 Or UInt32.
+For more information, see the link: [xxHash](http://cyan4973.github.io/xxHash/)
 
 [Original article](https://clickhouse.yandex/docs/en/query_language/functions/hash_functions/) <!--hide-->

docs/en/query_language/functions/higher_order_functions.md

@@ -87,6 +87,20 @@ SELECT arrayCumSum([1, 1, 1, 1]) AS res
 └──────────────┘
 ```
 
+### arrayCumSumNonNegative(arr)
+
+Same as arrayCumSum, returns an array of partial sums of elements in the source array (a running sum). Different arrayCumSum, when then returned value contains a value less than zero, the value is replace with zero and the subsequent calculation is performed with zero parameters. For example:
+
+``` sql
+SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res
+```
+
+```
+┌─res───────┐
+│ [1,2,0,1] │
+└───────────┘
+```
+
 ### arraySort(\[func,\] arr1, ...)
 
 Returns an array as result of sorting the elements of `arr1` in ascending order. If the `func` function is specified, sorting order is determined by the result of the function `func` applied to the elements of array (arrays)  
@@ -112,6 +126,6 @@ Returns an array as result of sorting the elements of `arr1` in descending order
 
 
 
- 
+
 
 [Original article](https://clickhouse.yandex/docs/en/query_language/functions/higher_order_functions/) <!--hide-->

docs/en/query_language/functions/ip_address_functions.md

@@ -113,5 +113,38 @@ LIMIT 10
 The reverse function of IPv6NumToString. If the IPv6 address has an invalid format, it returns a string of null bytes.
 HEX can be uppercase or lowercase.
 
+## IPv4ToIPv6(x)
+
+Takes a UInt32 number. Interprets it as an IPv4 address in big endian. Returns a FixedString(16) value containing the IPv6 address in binary format. Examples:
+
+``` sql
+SELECT IPv6NumToString(IPv4ToIPv6(IPv4StringToNum('192.168.0.1'))) AS addr
+```
+
+```
+┌─addr───────────────┐
+│ ::ffff:192.168.0.1 │
+└────────────────────┘
+```
+
+## cutIPv6(x, bitsToCutForIPv6, bitsToCutForIPv4)
+
+Accepts a FixedString(16) value containing the IPv6 address in binary format. Returns a string containing the address of the specified number of bits removed in text format. For example:
+
+```sql
+WITH
+    IPv6StringToNum('2001:0DB8:AC10:FE01:FEED:BABE:CAFE:F00D') AS ipv6,
+    IPv4ToIPv6(IPv4StringToNum('192.168.0.1')) AS ipv4
+SELECT
+    cutIPv6(ipv6, 2, 0),
+    cutIPv6(ipv4, 0, 2)
+
+```
+
+```
+┌─cutIPv6(ipv6, 2, 0)─────────────────┬─cutIPv6(ipv4, 0, 2)─┐
+│ 2001:db8:ac10:fe01:feed:babe:cafe:0 │ ::ffff:192.168.0.0  │
+└─────────────────────────────────────┴─────────────────────┘
+```
 
 [Original article](https://clickhouse.yandex/docs/en/query_language/functions/ip_address_functions/) <!--hide-->

docs/en/query_language/functions/math_functions.md

@@ -14,7 +14,7 @@ Returns a Float64 number that is close to the number π.
 
 Accepts a numeric argument and returns a Float64 number close to the exponent of the argument.
 
-## log(x)
+## log(x), ln(x)
 
 Accepts a numeric argument and returns a Float64 number close to the natural logarithm of the argument.
 
@@ -94,8 +94,16 @@ The arc cosine.
 
 The arc tangent.
 
-## pow(x, y)
+## pow(x, y), power(x, y)
 
 Takes two numeric arguments x and y. Returns a Float64 number close to x to the power of y.
 
+## intExp2
+
+Accepts a numeric argument and returns a UInt64 number close to 2 to the power of x.
+
+## intExp10
+
+Accepts a numeric argument and returns a UInt64 number close to 10 to the power of x.
+
 [Original article](https://clickhouse.yandex/docs/en/query_language/functions/math_functions/) <!--hide-->

docs/en/query_language/functions/other_functions.md

@@ -44,6 +44,10 @@ However, the argument is still evaluated. This can be used for benchmarks.
 
 Sleeps 'seconds' seconds on each data block. You can specify an integer or a floating-point number.
 
+## sleepEachRow(seconds)
+
+Sleeps 'seconds' seconds on each row. You can specify an integer or a floating-point number.
+
 ## currentDatabase()
 
 Returns the name of the current database.
@@ -242,6 +246,18 @@ Returns the server's uptime in seconds.
 
 Returns the version of the server as a string.
 
+## timezone()
+
+Returns the timezone of the server.
+
+## blockNumber
+
+Returns the sequence number of the data block where the row is located.
+
+## rowNumberInBlock
+
+Returns the ordinal number of the row in the data block. Different data blocks are always recalculated.
+
 ## rowNumberInAllBlocks()
 
 Returns the ordinal number of the row in the data block. This function only considers the affected data blocks.
@@ -283,6 +299,10 @@ FROM
 └─────────┴─────────────────────┴───────┘
 ```
 
+## runningDifferenceStartingWithFirstValue
+
+Same as for [runningDifference](./other_functions.md#runningDifference), the difference is the value of the first row, returned the value of the first row, and each subsequent row returns the difference from the previous row.
+
 ## MACNumToString(num)
 
 Accepts a UInt64 number. Interprets it as a MAC address in big endian. Returns a string containing the corresponding MAC address in the format AA:BB:CC:DD:EE:FF (colon-separated numbers in hexadecimal form).
@@ -440,7 +460,7 @@ The expression passed to the function is not calculated, but ClickHouse applies
 
 **Returned value**
 
-- 1. 
+- 1.
 
 **Example**
 
@@ -558,5 +578,34 @@ SELECT replicate(1, ['a', 'b', 'c'])
 └───────────────────────────────┘
 ```
 
+## filesystemAvailable
+
+Returns the remaining space information of the disk, in bytes. This information is evaluated using the configured by path.
+
+## filesystemCapacity
+
+Returns the capacity information of the disk, in bytes. This information is evaluated using the configured by path.
+
+## finalizeAggregation
+
+Takes state of aggregate function. Returns result of aggregation (finalized state).
+
+## runningAccumulate
+
+Takes the states of the aggregate function and returns a column with values, are the result of the accumulation of these states for a set of block lines, from the first to the current line.
+For example, takes state of aggregate function (example runningAccumulate(uniqState(UserID))), and for each row of block, return result of aggregate function on merge of states of all previous rows and current row.
+So, result of function depends on partition of data to blocks and on order of data in block.
+
+## joinGet('join_storage_table_name', 'get_column', join_key)
+
+Get data from a table of type Join using the specified join key.
+
+## modelEvaluate(model_name, ...)
+Evaluate external model.
+Accepts a model name and model arguments. Returns Float64.
+
+## throwIf(x)
+
+Throw an exception if the argument is non zero.
 
 [Original article](https://clickhouse.yandex/docs/en/query_language/functions/other_functions/) <!--hide-->

docs/en/query_language/functions/random_functions.md

@@ -16,5 +16,8 @@ Uses a linear congruential generator.
 Returns a pseudo-random UInt64 number, evenly distributed among all UInt64-type numbers.
 Uses a linear congruential generator.
 
+## randConstant
+
+Returns a pseudo-random UInt32 number, The value is one for different blocks.
 
 [Original article](https://clickhouse.yandex/docs/en/query_language/functions/random_functions/) <!--hide-->

docs/en/query_language/functions/rounding_functions.md

@@ -12,7 +12,7 @@ Examples: `floor(123.45, 1) = 123.4, floor(123.45, -1) = 120.`
 For integer arguments, it makes sense to round with a negative 'N' value (for non-negative 'N', the function doesn't do anything).
 If rounding causes overflow (for example, floor(-128, -1)), an implementation-specific result is returned.
 
-## ceil(x\[, N\])
+## ceil(x\[, N\]), ceiling(x\[, N\])
 
 Returns the smallest round number that is greater than or equal to 'x'. In every other way, it is the same as the 'floor' function (see above).
 
@@ -66,5 +66,8 @@ Accepts a number. If the number is less than one, it returns 0. Otherwise, it ro
 
 Accepts a number. If the number is less than 18, it returns 0. Otherwise, it rounds the number down to a number from the set: 18, 25, 35, 45, 55. This function is specific to Yandex.Metrica and used for implementing the report on user age.
 
+## roundDown(num, arr)
+
+Accept a number, round it down to an element in the specified array. If the value is less than the lowest bound, the lowest bound is returned.
 
 [Original article](https://clickhouse.yandex/docs/en/query_language/functions/rounding_functions/) <!--hide-->

docs/en/query_language/functions/string_functions.md

@@ -24,11 +24,21 @@ The function also works for arrays.
 Returns the length of a string in Unicode code points (not in characters), assuming that the string contains a set of bytes that make up UTF-8 encoded text. If this assumption is not met, it returns some result (it doesn't throw an exception).
 The result type is UInt64.
 
-## lower
+## char_length, CHAR_LENGTH
+
+Returns the length of a string in Unicode code points (not in characters), assuming that the string contains a set of bytes that make up UTF-8 encoded text. If this assumption is not met, it returns some result (it doesn't throw an exception).
+The result type is UInt64.
+
+## character_length, CHARACTER_LENGTH
+
+Returns the length of a string in Unicode code points (not in characters), assuming that the string contains a set of bytes that make up UTF-8 encoded text. If this assumption is not met, it returns some result (it doesn't throw an exception).
+The result type is UInt64.
+
+## lower, lcase
 
 Converts ASCII Latin symbols in a string to lowercase.
 
-## upper
+## upper, ucase
 
 Converts ASCII Latin symbols in a string to uppercase.
 
@@ -58,7 +68,11 @@ Reverses a sequence of Unicode code points, assuming that the string contains a
 
 Concatenates the strings listed in the arguments, without a separator.
 
-## substring(s, offset, length)
+## concatAssumeInjective(s1, s2, ...)
+
+Same as [concat](./string_functions.md#concat-s1-s2), the difference is that you need to ensure that concat(s1, s2, s3) -> s4 is injective, it will be used for optimization of GROUP BY
+
+## substring(s, offset, length), mid(s, offset, length), substr(s, offset, length)
 
 Returns a substring starting with the byte from the 'offset' index that is 'length' bytes long. Character indexing starts from one (as in standard SQL). The 'offset' and 'length' arguments must be constants.
 
@@ -83,4 +97,24 @@ Decode base64-encoded string 's' into original string. In case of failure raises
 ## tryBase64Decode(s)
 Similar to base64Decode, but in case of error an empty string would be returned.
 
-[Original article](https://clickhouse.yandex/docs/en/query_language/functions/string_functions/) <!--hide-->
\ No newline at end of file
+## endsWith(s, suffix)
+
+Returns whether to end with the specified suffix. Returns 1 if the string ends with the specified suffix, otherwise it returns 0.
+
+## startsWith(s, prefix)
+
+Returns whether to end with the specified prefix. Returns 1 if the string ends with the specified prefix, otherwise it returns 0.
+
+## trimLeft(s)
+
+Returns a string that removes the whitespace characters on left side.
+
+## trimRight(s)
+
+Returns a string that removes the whitespace characters on right side.
+
+## trimBoth(s)
+
+Returns a string that removes the whitespace characters on either side.
+
+[Original article](https://clickhouse.yandex/docs/en/query_language/functions/string_functions/) <!--hide-->

docs/en/query_language/functions/string_replace_functions.md

@@ -5,7 +5,7 @@
 Replaces the first occurrence, if it exists, of the 'pattern' substring in 'haystack' with the 'replacement' substring.
 Hereafter, 'pattern' and 'replacement' must be constants.
 
-## replaceAll(haystack, pattern, replacement)
+## replaceAll(haystack, pattern, replacement), replace(haystack, pattern, replacement)
 
 Replaces all occurrences of the 'pattern' substring in 'haystack' with the 'replacement' substring.
 
@@ -78,4 +78,12 @@ SELECT replaceRegexpAll('Hello, World!', '^', 'here: ') AS res
 ```
 
 
+## regexpQuoteMeta(s)
+
+The function adds a backslash before some predefined characters in the string.
+Predefined characters: '0', '\\', '|', '(', ')', '^', '$', '.', '[', ']', '?', '*', '+', '{', ':', '-'.
+This implementation slightly differs from re2::RE2::QuoteMeta. It escapes zero byte as \0 instead of \x00 and it escapes only required characters.
+For more information, see the link: [RE2](https://github.com/google/re2/blob/master/re2/re2.cc#L473)
+
+
 [Original article](https://clickhouse.yandex/docs/en/query_language/functions/string_replace_functions/) <!--hide-->

docs/en/query_language/functions/string_search_functions.md

@@ -3,7 +3,7 @@
 The search is case-sensitive in all these functions.
 The search substring or regular expression must be a constant in all these functions.
 
-## position(haystack, needle)
+## position(haystack, needle), locate(haystack, needle)
 
 Search for the substring `needle` in the string `haystack`.
 Returns the position (in bytes) of the found substring, starting from 1, or returns 0 if the substring was not found.

docs/en/query_language/functions/type_conversion_functions.md

@@ -7,10 +7,12 @@
 
 ## toFloat32, toFloat64
 
-## toUInt8OrZero, toUInt16OrZero, toUInt32OrZero, toUInt64OrZero, toInt8OrZero, toInt16OrZero, toInt32OrZero, toInt64OrZero, toFloat32OrZero, toFloat64OrZero
-
 ## toDate, toDateTime
 
+## toUInt8OrZero, toUInt16OrZero, toUInt32OrZero, toUInt64OrZero, toInt8OrZero, toInt16OrZero, toInt32OrZero, toInt64OrZero, toFloat32OrZero, toFloat64OrZero, toDateOrZero, toDateTimeOrZero
+
+## toUInt8OrNull, toUInt16OrNull, toUInt32OrNull, toUInt64OrNull, toInt8OrNull, toInt16OrNull, toInt32OrNull, toInt64OrNull, toFloat32OrNull, toFloat64OrNull, toDateOrNull, toDateTimeOrNull
+
 ## toDecimal32(value, S), toDecimal64(value, S), toDecimal128(value, S)
 
 Converts `value` to [Decimal](../../data_types/decimal.md) of precision `S`. The `value` can be a number or a string. The `S` (scale) parameter specifies the number of decimal places.
@@ -99,6 +101,9 @@ These functions accept a string and interpret the bytes placed at the beginning
 
 This function accepts a number or date or date with time, and returns a string containing bytes representing the corresponding value in host order (little endian). Null bytes are dropped from the end. For example, a UInt32 type value of 255 is a string that is one byte long.
 
+## reinterpretAsFixedString
+
+This function accepts a number or date or date with time, and returns a FixedString containing bytes representing the corresponding value in host order (little endian). Null bytes are dropped from the end. For example, a UInt32 type value of 255 is a FixedString that is one byte long.
 
 ## CAST(x, t)
 
@@ -141,5 +146,39 @@ SELECT toTypeName(CAST(x, 'Nullable(UInt16)')) FROM t_null
 └─────────────────────────────────────────┘
 ```
 
+## toIntervalYear, toIntervalQuarter, toIntervalMonth, toIntervalWeek, toIntervalDay, toIntervalHour, toIntervalMinute, toIntervalSecond
+
+Converts a Number type argument to a Interval type (duration).
+The interval type is actually very useful, you can use this type of data to perform arithmetic operations directly with Date or DateTime. At the same time, ClickHouse provides a more convenient syntax for declaring Interval type data. For example:
+
+```sql
+WITH 
+    toDate('2019-01-01') AS date, 
+    INTERVAL 1 WEEK AS interval_week, 
+    toIntervalWeek(1) AS interval_to_week
+SELECT 
+    date + interval_week, 
+    date + interval_to_week
+```
+
+```
+┌─plus(date, interval_week)─┬─plus(date, interval_to_week)─┐
+│                2019-01-08 │                   2019-01-08 │
+└───────────────────────────┴──────────────────────────────┘
+```
+
+## parseDateTimeBestEffort
+
+Parse a number type argument to a Date or DateTime type.
+different from toDate and toDateTime, parseDateTimeBestEffort can progress more complex date format.
+For more information, see the link: [Complex Date Format](https://xkcd.com/1179/)
+
+## parseDateTimeBestEffortOrNull
+
+Same as for [parseDateTimeBestEffort](./type_conversion_functions.md#parseDateTimeBestEffort) except that it returns null when it encounters a date format that cannot be processed.
+
+## parseDateTimeBestEffortOrZero
+
+Same as for [parseDateTimeBestEffort](./type_conversion_functions.md#parseDateTimeBestEffort) except that it returns zero date or zero date time when it encounters a date format that cannot be processed.
 
 [Original article](https://clickhouse.yandex/docs/en/query_language/functions/type_conversion_functions/) <!--hide-->