Review feedback

Author: Blargian

src/Functions/array/arrayDifference.cpp

@@ -168,12 +168,12 @@ REGISTER_FUNCTION(ArrayDifference)
 {
     FunctionDocumentation::Description description = R"(
 Calculates an array of differences between adjacent array elements.
-The first element of the result array will be 0, the second `a[1] - a[0]`, the third `a[2] - a[1]`, etc.
+The first element of the result array will be 0, the second `arr[1] - arr[0]`, the third `arr[2] - arr[1]`, etc.
 The type of elements in the result array are determined by the type inference rules for subtraction (e.g. `UInt8` - `UInt8` = `Int16`).
     )";
-    FunctionDocumentation::Syntax syntax = "arrayDifference(x)";
+    FunctionDocumentation::Syntax syntax = "arrayDifference(arr)";
     FunctionDocumentation::Arguments argument = {
-        {"x", "Array for which to calculate differences between adjacent elements. [`Array`](/sql-reference/data-types/array)."},
+        {"arr", "Array for which to calculate differences between adjacent elements. [`Array(T)`](/sql-reference/data-types/array)."},
     };
     FunctionDocumentation::ReturnedValue returned_value = "Returns an array of differences between adjacent array elements. [`UInt*`](/sql-reference/data-types/int-uint#integer-ranges), [`Int*`](/sql-reference/data-types/int-uint#integer-ranges), [`Float*`](/sql-reference/data-types/float).";
     FunctionDocumentation::Examples examples = {

src/Functions/array/arrayDistinct.cpp

@@ -290,11 +290,11 @@ void FunctionArrayDistinct::executeHashed(
 REGISTER_FUNCTION(ArrayDistinct)
 {
     FunctionDocumentation::Description description = "Returns an array containing only the distinct elements of an array.";
-    FunctionDocumentation::Syntax syntax = "arrayDistinct(x)";
+    FunctionDocumentation::Syntax syntax = "arrayDistinct(arr)";
     FunctionDocumentation::Arguments argument = {
-        {"x", "Array for which to extract distinct elements. [`Array`](/sql-reference/data-types/array)."},
+        {"arr", "Array for which to extract distinct elements. [`Array(T)`](/sql-reference/data-types/array)."},
     };
-    FunctionDocumentation::ReturnedValue returned_value = "Returns an array containing the distinct elements.";
+    FunctionDocumentation::ReturnedValue returned_value = "Returns an array containing the distinct elements. [`Array(T)`](/sql-reference/data-types/array).";
     FunctionDocumentation::Examples examples = {{"Usage example", "SELECT arrayDistinct([1, 2, 2, 3, 1]);", "[1,2,3]"}};
     FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;

src/Functions/array/arrayEnumerateDense.cpp

@@ -17,11 +17,11 @@ class FunctionArrayEnumerateDense : public FunctionArrayEnumerateExtended<Functi
 REGISTER_FUNCTION(ArrayEnumerateDense)
 {
     FunctionDocumentation::Description description = "Returns an array of the same size as the source array, indicating where each element first appears in the source array.";
-    FunctionDocumentation::Syntax syntax = "arrayEnumerateDense(x)";
+    FunctionDocumentation::Syntax syntax = "arrayEnumerateDense(arr)";
     FunctionDocumentation::Arguments arguments = {
-        {"x", "The array to enumerate. [`Array`](/sql-reference/data-types/array)."}
+        {"arr", "The array to enumerate. [`Array(T)`](/sql-reference/data-types/array)."}
     };
-    FunctionDocumentation::ReturnedValue returned_value = "Returns an array of the same size as `x`, indicating where each element first appears in the source array. [`Array`](/sql-reference/data-types/array).";
+    FunctionDocumentation::ReturnedValue returned_value = "Returns an array of the same size as `arr`, indicating where each element first appears in the source array. [`Array(T)`](/sql-reference/data-types/array).";
     FunctionDocumentation::Examples examples = {{"Usage example", "SELECT arrayEnumerateDense([10, 20, 10, 30])", "[1,2,1,3]"}};
     FunctionDocumentation::IntroducedIn introduced_in = {18, 12};
     FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;

src/Functions/array/arrayEnumerateDenseRanked.cpp

@@ -20,8 +20,8 @@ REGISTER_FUNCTION(ArrayEnumerateDenseRanked)
     FunctionDocumentation::Syntax syntax = "arrayEnumerateDenseRanked(clear_depth, arr, max_array_depth)";
     FunctionDocumentation::Arguments arguments = {
         {"clear_depth", "Enumerate elements at the specified level separately. Positive [Integer](../data-types/int-uint.md) less than or equal to `max_arr_depth`."},
-        {"x", "N-dimensional array to enumerate. [Array](/sql-reference/data-types/array)."},
-        {"max_array_depth", "The maximum effective depth. Positive [Integer](../data-types/int-uint.md) less than or equal to the depth of `arr`."},
+        {"arr", "N-dimensional array to enumerate. [`Array(T)`](/sql-reference/data-types/array)."},
+        {"max_array_depth", "The maximum effective depth. Positive [(U)Int*](../data-types/int-uint.md) less than or equal to the depth of `arr`."},
     };
     FunctionDocumentation::ReturnedValue returned_value = "Returns an array denoting where each element first appears in the source array. [Array](/sql-reference/data-types/array).";
     FunctionDocumentation::Examples examples = {

src/Functions/array/arrayIntersect.cpp

@@ -767,9 +767,9 @@ using ArraySymmetricDifference = FunctionArrayIntersect<ArrayModeSymmetricDiffer
 REGISTER_FUNCTION(ArrayIntersect)
 {
     FunctionDocumentation::Description intersect_description = "Takes multiple arrays and returns an array with elements which are present in all source arrays. The result contains only unique values.";
-    FunctionDocumentation::Syntax intersect_syntax = "arrayIntersect(x, x1, ..., xN)";
-    FunctionDocumentation::Arguments intersect_argument = {{"xN", "N arrays from which to make the new array. [`Array`](/sql-reference/data-types/array)."}};
-    FunctionDocumentation::ReturnedValue intersect_returned_value = "Returns an array with distinct elements that are present in all N arrays. [`Array`](/sql-reference/data-types/array).";
+    FunctionDocumentation::Syntax intersect_syntax = "arrayIntersect(arr, arr1, ..., arrN)";
+    FunctionDocumentation::Arguments intersect_argument = {{"arrN", "N arrays from which to make the new array. [`Array(T)`](/sql-reference/data-types/array)."}};
+    FunctionDocumentation::ReturnedValue intersect_returned_value = "Returns an array with distinct elements that are present in all N arrays. [`Array(T)`](/sql-reference/data-types/array).";
     FunctionDocumentation::Examples intersect_example = {{"Usage example",
 R"(SELECT
 arrayIntersect([1, 2], [1, 3], [2, 3]) AS empty_intersection,
@@ -786,9 +786,9 @@ arrayIntersect([1, 2], [1, 3], [1, 4]) AS non_empty_intersection
     factory.registerFunction<ArrayIntersect>(intersect_documentation);
 
     FunctionDocumentation::Description union_description = "Takes multiple arrays and returns an array which contains all elements that are present in one of the source arrays.The result contains only unique values.";
-    FunctionDocumentation::Syntax union_syntax = "arrayUnion(x1, x2, ..., xN)";
-    FunctionDocumentation::Arguments union_argument = {{"xN", "N arrays from which to make the new array. [`Array`](/sql-reference/data-types/array)."}};
-    FunctionDocumentation::ReturnedValue union_returned_value = "Returns an array with distinct elements from the source arrays. [`Array`](/sql-reference/data-types/array).";
+    FunctionDocumentation::Syntax union_syntax = "arrayUnion(arr1, arr2, ..., arrN)";
+    FunctionDocumentation::Arguments union_argument = {{"arrN", "N arrays from which to make the new array. [`Array(T)`](/sql-reference/data-types/array)."}};
+    FunctionDocumentation::ReturnedValue union_returned_value = "Returns an array with distinct elements from the source arrays. [`Array(T)`](/sql-reference/data-types/array).";
     FunctionDocumentation::Examples union_example = {{"Usage example",
 R"(SELECT
 arrayUnion([-2, 1], [10, 1], [-2], []) as num_example,
@@ -813,9 +813,9 @@ as the set of all input elements which occur in an odd number of input sets.
 In contrast, function `arraySymmetricDifference` simply returns the set of input elements which do not occur in all input sets.
 :::
 )";
-    FunctionDocumentation::Syntax symdiff_syntax = "arraySymmetricDifference(x1, x2, ..., xN)";
-    FunctionDocumentation::Arguments symdiff_argument = {{"xN", "N arrays from which to make the new array. [`Array`](/sql-reference/data-types/array)."}};
-    FunctionDocumentation::ReturnedValue symdiff_returned_value = "Returns an array of distinct elements not present in all source arrays. [`Array`](/sql-reference/data-types/array).";
+    FunctionDocumentation::Syntax symdiff_syntax = "arraySymmetricDifference(arr1, arr2, ... , arrN)";
+    FunctionDocumentation::Arguments symdiff_argument = {{"arrN", "N arrays from which to make the new array. [`Array(T)`](/sql-reference/data-types/array)."}};
+    FunctionDocumentation::ReturnedValue symdiff_returned_value = "Returns an array of distinct elements not present in all source arrays. [`Array(T)`](/sql-reference/data-types/array).";
     FunctionDocumentation::Examples symdiff_example = {{"Usage example", R"(SELECT
 arraySymmetricDifference([1, 2], [1, 2], [1, 2]) AS empty_symmetric_difference,
 arraySymmetricDifference([1, 2], [1, 2], [1, 3]) AS non_empty_symmetric_difference;

src/Functions/array/arrayJoin.cpp

@@ -85,11 +85,11 @@ and Aggregate Functions which take a group of rows and "compress" or "reduce" th
 All the values in the columns are simply copied, except the values in the column where this function is applied;
 these are replaced with the corresponding array value.
 )";
-    FunctionDocumentation::Syntax syntax = "arrayJoin(x)";
+    FunctionDocumentation::Syntax syntax = "arrayJoin(arr)";
     FunctionDocumentation::Arguments arguments = {
-        {"x", "An array to unfold. [`Array`](/sql-reference/data-types/array)"}
+        {"arr", "An array to unfold. [`Array(T)`](/sql-reference/data-types/array)."}
     };
-    FunctionDocumentation::ReturnedValue returned_value = "Returns a set of rows unfolded from `x`.";
+    FunctionDocumentation::ReturnedValue returned_value = "Returns a set of rows unfolded from `arr`.";
     FunctionDocumentation::Examples examples = {
         {"Basic usage", R"(SELECT arrayJoin([1, 2, 3] AS src) AS dst, 'Hello', src)", R"(
 ┌─dst─┬─\'Hello\'─┬─src─────┐

src/Functions/array/arrayUniq.cpp

@@ -329,24 +329,26 @@ For example `SELECT arrayUniq([1,2], [3,4], [5,6])` will form the following tupl
 
 It will then count the number of unique tuples. In this case `2`.
 
+All arrays passed must have the same length.
+
 :::tip
 If you want to get a list of unique items in an array, you can use `arrayReduce('groupUniqArray', arr)`.
 :::
 )";
-    FunctionDocumentation::Syntax syntax = "arrayUniq(x[, ...yN])";
+    FunctionDocumentation::Syntax syntax = "arrayUniq(arr1[, arr2, ..., arrN])";
     FunctionDocumentation::Arguments arguments = {
         {
-            "x",
-            "Array for which to count the number of unique elements. [`Array`](/sql-reference/data-types/array)."
+            "arr1",
+            "Array for which to count the number of unique elements. [`Array(T)`](/sql-reference/data-types/array)."
         },
         {
-            "...yN (optional)",
-            "Additional same-size arrays used to count the number of unique tuples of elements at corresponding positions in multiple arrays. [`Array`](/sql-reference/data-types/array)."
+            "[, arr2, ..., arrN] (optional)",
+            "Optional. Additional arrays used to count the number of unique tuples of elements at corresponding positions in multiple arrays. [`Array(T)`](/sql-reference/data-types/array)."
         }
     };
     FunctionDocumentation::Examples examples =
-{{"Single argument", "SELECT arrayUniq([1,1,2,2])", "2"},
-{"Multiple argument", "SELECT arrayUniq([1,2,3], [4,5,6])", "3"}};
+{{"Single argument", "SELECT arrayUniq([1, 1, 2, 2])", "2"},
+{"Multiple argument", "SELECT arrayUniq([1, 2, 3, 1], [4, 5, 6, 4])", "3"}};
     FunctionDocumentation::ReturnedValue returned_value = R"(
 For a single argument returns the number of unique
 elements. For multiple arguments returns the number of unique tuples made from