Review changes

Author: Blargian

src/Functions/array/arrayCount.cpp

@@ -85,16 +85,12 @@ REGISTER_FUNCTION(ArrayCount)
 Returns the number of elements for which `func(arr1[i], ..., arrN[i])` returns something other than `0`.
 If `func` is not specified, it returns the number of non-zero elements in the array.
 
-:::note
-Note that the `arrayCount` is a [higher-order function](/sql-reference/functions/overview#higher-order-functions).
-You can pass a lambda function to it as the first argument.
-:::
-
+`arrayCount` is a [higher-order function](/sql-reference/functions/overview#higher-order-functions).
     )";
-    FunctionDocumentation::Syntax syntax = "arrayCount([func,] arr1, ...)";
+    FunctionDocumentation::Syntax syntax = "arrayCount([func, ] arr1, ...)";
     FunctionDocumentation::Arguments arguments = {
-        {"func", "Function to apply to each element of the array(s). [Lambda function](/sql-reference/functions/overview#arrow-operator-and-lambda)"},
-        {"arr1 ... arrN", "N arrays. [Array](/sql-reference/data-types/array)."},
+        {"func", "Function to apply to each element of the array(s). Optional. [Lambda function](/sql-reference/functions/overview#arrow-operator-and-lambda)"},
+        {"arr1, ..., arrN", "N arrays. [Array(T)](/sql-reference/data-types/array)."},
     };
     FunctionDocumentation::ReturnedValue returned_value = "Returns the number of elements for which `func` returns something other than `0`. Otherwise, returns the number of non-zero elements in the array.";
     FunctionDocumentation::Examples example = {{"Usage example", "SELECT arrayCount(x -> (x % 2), groupArray(number) FROM numbers(10)", "5"}};

src/Functions/array/arrayDotProduct.cpp

@@ -388,16 +388,14 @@ REGISTER_FUNCTION(ArrayDotProduct)
     FunctionDocumentation::Description description = R"(
 Returns the dot product of two arrays.
 
-Aliases: `scalarProduct`, `dotProduct`
-
 :::note
 The sizes of the two vectors must be equal. Arrays and Tuples may also contain mixed element types.
 :::
 )";
     FunctionDocumentation::Syntax syntax = "arrayDotProduct(v1, v2)";
     FunctionDocumentation::Arguments arguments = {
-        {"v1", "First vector. [Array](/sql-reference/data-types/array) or [Tuple](../data-types/tuple.md) of numeric values."},
-        {"v2", "Second vector. [Array](/sql-reference/data-types/array) or [Tuple](../data-types/tuple.md) of numeric values."},
+        {"v1", "First vector. [Array(T)](/sql-reference/data-types/array) or [Tuple(T1, T2, ...)](../data-types/tuple.md) of numeric values."},
+        {"v2", "Second vector. [Array(T)](/sql-reference/data-types/array) or [Tuple(T1, T2, ...)](../data-types/tuple.md) of numeric values."},
     };
     FunctionDocumentation::ReturnedValue returned_value = R"(
 The dot product of the two vectors. [Numeric](/native-protocol/columns#numeric-types).
@@ -410,7 +408,7 @@ The return type is determined by the type of the arguments. If Arrays or Tuples
         {"Array example", "SELECT arrayDotProduct([1, 2, 3], [4, 5, 6]) AS res, toTypeName(res);", "32    UInt16"},
         {"Tuple example", "SELECT dotProduct((1::UInt16, 2::UInt8, 3::Float32),(4::Int16, 5::Float32, 6::UInt8)) AS res, toTypeName(res);", "32    Float64"}
     };
-    FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
+    FunctionDocumentation::IntroducedIn introduced_in = {23, 5};
     FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;
     FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, category};
 

src/Functions/array/arrayEnumerate.cpp

@@ -83,9 +83,9 @@ This function is normally used with the [`ARRAY JOIN`](/sql-reference/statements
 once for each array after applying `ARRAY JOIN`.
 This function can also be used in higher-order functions. For example, you can use it to get array indexes for elements that match a condition.
 )";
-    FunctionDocumentation::Syntax syntax = "arrayEnumerate(x)";
+    FunctionDocumentation::Syntax syntax = "arrayEnumerate(arr)";
     FunctionDocumentation::Arguments arguments = {
-        {"x", "The array to enumerate. [`Array`](/sql-reference/data-types/array)."}
+        {"arr", "The array to enumerate. [`Array`](/sql-reference/data-types/array)."}
     };
     FunctionDocumentation::ReturnedValue returned_value = "Returns the array `[1, 2, 3, ..., length (arr)]`. Array(UInt32)";
     FunctionDocumentation::Examples examples = {{"Basic example with ARRAY JOIN", R"(

src/Functions/array/arrayEnumerateUniqRanked.cpp

@@ -62,7 +62,7 @@ SELECT arrayEnumerateUniqRanked(2, [[1,2,3],[2,2,1],[3]], 2);
 ```
         )", "[[1,1,1],[1,2,1],[1]]"},
 };
-    FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
+    FunctionDocumentation::IntroducedIn introduced_in = {20, 1};
     FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;
     FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, category};
 

src/Functions/array/arrayPopBack.cpp

@@ -16,9 +16,9 @@ class FunctionArrayPopBack : public FunctionArrayPop
 REGISTER_FUNCTION(ArrayPopBack)
 {
     FunctionDocumentation::Description description = "Removes the last element from the array.";
-    FunctionDocumentation::Syntax syntax = "arrayPopBack(x)";
-    FunctionDocumentation::Arguments arguments = {{"x", "The array for which to remove the last element from. [`Array`](/sql-reference/data-types/array)."}};
-    FunctionDocumentation::ReturnedValue returned_value = "Returns an array identical to `x` but without the last element of `x`. [`Array`](/sql-reference/data-types/array).";
+    FunctionDocumentation::Syntax syntax = "arrayPopBack(arr)";
+    FunctionDocumentation::Arguments arguments = {{"arr", "The array for which to remove the last element from. [`Array(T)`](/sql-reference/data-types/array)."}};
+    FunctionDocumentation::ReturnedValue returned_value = "Returns an array identical to `arr` but without the last element of `arr`. [`Array(T)`](/sql-reference/data-types/array).";
     FunctionDocumentation::Examples examples = {{"Usage example", "SELECT arrayPopBack([1, 2, 3]) AS res;", "[1,2]"}};
     FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;

src/Functions/array/arrayPopFront.cpp

@@ -16,9 +16,9 @@ class FunctionArrayPopFront : public FunctionArrayPop
 REGISTER_FUNCTION(ArrayPopFront)
 {
     FunctionDocumentation::Description description = "Removes the first item from the array.";
-    FunctionDocumentation::Syntax syntax = "arrayPopFront(x)";
-    FunctionDocumentation::Arguments arguments = {{"x", "The array for which to remove the first element from. [`Array`](/sql-reference/data-types/array)."}};
-    FunctionDocumentation::ReturnedValue returned_value = "Returns an array identical to `x` but without the first element of `x`. [`Array`](/sql-reference/data-types/array).";
+    FunctionDocumentation::Syntax syntax = "arrayPopFront(arr)";
+    FunctionDocumentation::Arguments arguments = {{"arr", "The array for which to remove the first element from. [`Array(T)`](/sql-reference/data-types/array)."}};
+    FunctionDocumentation::ReturnedValue returned_value = "Returns an array identical to `arr` but without the first element of `arr`. [`Array(T)`](/sql-reference/data-types/array).";
     FunctionDocumentation::Examples examples = {{"Usage example", "SELECT arrayPopFront([1, 2, 3]) AS res;", "[2,3]"}};
     FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;

src/Functions/array/arrayPushBack.cpp

@@ -16,22 +16,22 @@ class FunctionArrayPushBack : public FunctionArrayPush
 REGISTER_FUNCTION(ArrayPushBack)
 {
     FunctionDocumentation::Description description = "Adds one item to the end of the array.";
-    FunctionDocumentation::Syntax syntax = "arrayPushBack(x, y)";
+    FunctionDocumentation::Syntax syntax = "arrayPushBack(arr, x)";
     FunctionDocumentation::Arguments arguments = {
-        {"x", "The array for which to add value `y` to the end of. [`Array`](/sql-reference/data-types/array)."},
-        {"y", R"(
-- Single value to add to the end of the array. [`Array`](/sql-reference/data-types/array).
+        {"arr", "The array for which to add value `x` to the end of. [`Array(T)`](/sql-reference/data-types/array)."},
+        {"x", R"(
+- Single value to add to the end of the array. [`Array(T)`](/sql-reference/data-types/array).
 
 :::note
 - Only numbers can be added to an array with numbers, and only strings can be added to an array of strings.
-- When adding numbers, ClickHouse automatically sets the type of `y` for the data type of the array.
+- When adding numbers, ClickHouse automatically sets the type of `x` for the data type of the array.
 - Can be `NULL`. The function adds a `NULL` element to an array, and the type of array elements converts to `Nullable`.
 
 For more information about the types of data in ClickHouse, see [Data types](/sql-reference/data-types).
 :::
     )"},
     };
-    FunctionDocumentation::ReturnedValue returned_value = "Returns an array identical to `x` but with an additional value `y` at the end of the array. [`Array`](/sql-reference/data-types/array).";
+    FunctionDocumentation::ReturnedValue returned_value = "Returns an array identical to `arr` but with an additional value `x` at the end of the array. [`Array(T)`](/sql-reference/data-types/array).";
     FunctionDocumentation::Examples examples = {{"Usage example", "SELECT arrayPushBack(['a'], 'b') AS res;", "['a','b']"}};
     FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;

src/Functions/array/arrayPushFront.cpp

@@ -18,22 +18,22 @@ class FunctionArrayPushFront : public FunctionArrayPush
 REGISTER_FUNCTION(ArrayPushFront)
 {
     FunctionDocumentation::Description description = "Adds one element to the beginning of the array.";
-    FunctionDocumentation::Syntax syntax = "arrayPushFront(x, y)";
+    FunctionDocumentation::Syntax syntax = "arrayPushFront(arr, x)";
     FunctionDocumentation::Arguments arguments = {
-        {"x", "The array for which to add value `y` to the end of. [`Array`](/sql-reference/data-types/array)."},
-        {"y", R"(
-- Single value to add to the start of the array. [`Array`](/sql-reference/data-types/array).
+        {"arr", "The array for which to add value `x` to the end of. [`Array(T)`](/sql-reference/data-types/array)."},
+        {"x", R"(
+- Single value to add to the start of the array. [`Array(T)`](/sql-reference/data-types/array).
 
 :::note
 - Only numbers can be added to an array with numbers, and only strings can be added to an array of strings.
-- When adding numbers, ClickHouse automatically sets the type of `y` for the data type of the array.
+- When adding numbers, ClickHouse automatically sets the type of `x` for the data type of the array.
 - Can be `NULL`. The function adds a `NULL` element to an array, and the type of array elements converts to `Nullable`.
 
 For more information about the types of data in ClickHouse, see [Data types](/sql-reference/data-types).
 :::
     )"},
     };
-    FunctionDocumentation::ReturnedValue returned_value = "Returns an array identical to `x` but with an additional value `y` at the beginning of the array. [`Array`](/sql-reference/data-types/array).";
+    FunctionDocumentation::ReturnedValue returned_value = "Returns an array identical to `arr` but with an additional value `x` at the beginning of the array. [`Array(T)`](/sql-reference/data-types/array).";
     FunctionDocumentation::Examples examples = {{"Usage example", "SELECT arrayPushFront(['b'], 'a') AS res;", "['a','b']"}};
     FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;

src/Functions/array/countEqual.cpp

@@ -16,10 +16,10 @@ Returns the number of elements in the array equal to `x`. Equivalent to `arrayCo
 )";
     FunctionDocumentation::Syntax syntax = "countEqual(arr, x)";
     FunctionDocumentation::Arguments arguments = {
-        {"arr", "Array to search. [`Array`](/sql-reference/data-types/array)."},
+        {"arr", "Array to search. [`Array(T)`](/sql-reference/data-types/array)."},
         {"x", "Value in the array to count. Any type."}
     };
-    FunctionDocumentation::ReturnedValue returned_value = "Returns the number of elements in the array equal to `x`. UInt64.";
+    FunctionDocumentation::ReturnedValue returned_value = "Returns the number of elements in the array equal to `x`. [UInt64](/sql-reference/data-types/int-uint).";
     FunctionDocumentation::Examples example = {{"Usage example", "SELECT countEqual([1, 2, NULL, NULL], NULL)", "2"}};
     FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;

src/Functions/array/hasAll.cpp

@@ -32,19 +32,14 @@ Checks whether one array is a subset of another.
 - `1`, if `set` contains all of the elements from `subset`.
 - `0`, otherwise.
 
-Raises an exception `NO_COMMON_TYPE` if the set and subset elements do not share a common supertype.
+Raises a `NO_COMMON_TYPE` exception if the set and subset elements do not share a common supertype.
 )";
     FunctionDocumentation::Examples examples = {
         {"Empty arrays", "SELECT hasAll([], [])", "1"},
         {"Arrays containing NULL values", "SELECT hasAll([1, Null], [Null])", "1"},
         {"Arrays containing values of a different type", "SELECT hasAll([1.0, 2, 3, 4], [1, 3])", "1"},
         {"Arrays containing String values", "SELECT hasAll(['a', 'b'], ['a'])", "1"},
-        {"Arrays without a common type", "SELECT hasAll([1], ['a'])", R"(
-Received exception:
-Code: 386. DB::Exception:
-There is no supertype for types UInt8, String because some of them are String/FixedString/Enum and some of them are not:
-In scope SELECT hasAll([1], ['a']). (NO_COMMON_TYPE
-        )"},
+        {"Arrays without a common type", "SELECT hasAll([1], ['a'])", "Raises a NO_COMMON_TYPE exception"},
         {"Array of arrays", "SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]])", "0"},
     };
     FunctionDocumentation::IntroducedIn introduced_in = {1, 1};