Merge pull request ClickHouse#80345 from Blargian/array_functions_part_7

Docs: array functions source code documentation. Part 7

Author: Blargian

docs/en/sql-reference/functions/array-functions.md

@@ -2624,7 +2624,7 @@ Note that the `arrayLastIndex` is a [higher-order function](/sql-reference/funct
 
 Returns the minimum of elements in the source array.
 
-If the `func` function is specified, returns the mininum of elements converted by this function.
+If the `func` function is specified, returns the minimum of elements converted by this function.
 
 Note that the `arrayMin` is a [higher-order function](/sql-reference/functions/overview#higher-order-functions). You can pass a lambda function to it as the first argument.
 

src/Functions/array/arrayAggregation.cpp

@@ -446,11 +446,115 @@ using FunctionArrayProduct = FunctionArrayMapped<ArrayAggregateImpl<AggregateOpe
 
 REGISTER_FUNCTION(ArrayAggregation)
 {
-    factory.registerFunction<FunctionArrayMin>();
-    factory.registerFunction<FunctionArrayMax>();
-    factory.registerFunction<FunctionArraySum>();
-    factory.registerFunction<FunctionArrayAverage>();
-    factory.registerFunction<FunctionArrayProduct>();
+    FunctionDocumentation::Description description_min = R"(
+Returns the minimum element in the source array.
+
+If a lambda function `func` is specified, returns the minimum element of the lambda results.
+    )";
+    FunctionDocumentation::Syntax syntax_min = "arrayMin([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])";
+    FunctionDocumentation::Arguments arguments_min = {
+        {"func(x[, y1, ..., yN])", "Optional. A lambda function which operates on elements of the source array (`x`) and condition arrays (`y`). [Lambda function](/sql-reference/functions/overview#arrow-operator-and-lambda)."},
+        {"source_arr", "The source array to process [`Array(T)`](/sql-reference/data-types/array)."},
+        {"[, cond1_arr, ... , condN_arr]", "Optional. N condition arrays providing additional arguments to the lambda function. [`Array(T)`](/sql-reference/data-types/array)."},
+    };
+    FunctionDocumentation::ReturnedValue returned_value_min = "Returns the minimum element in the source array, or the minimum element of the lambda results if provided.";
+    FunctionDocumentation::Examples examples_min = {
+        {"Basic example", "SELECT arrayMin([5, 3, 2, 7]);", "2"},
+        {"Usage with lambda function", "SELECT arrayMin(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);", "4"},
+    };
+    FunctionDocumentation::IntroducedIn introduced_in_min = {21, 1};
+    FunctionDocumentation::Category category_min = FunctionDocumentation::Category::Array;
+    FunctionDocumentation documentation_min = {description_min, syntax_min, arguments_min, returned_value_min, examples_min, introduced_in_min, category_min};
+
+    factory.registerFunction<FunctionArrayMin>(documentation_min);
+
+    FunctionDocumentation::Description description_max = R"(
+Returns the maximum element in the source array.
+
+If a lambda function `func` is specified, returns the maximum element of the lambda results.
+    )";
+    FunctionDocumentation::Syntax syntax_max = "arrayMax([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])";
+    FunctionDocumentation::Arguments arguments_max = {
+        {"func(x[, y1, ..., yN])", "Optional. A lambda function which operates on elements of the source array (`x`) and condition arrays (`y`). [Lambda function](/sql-reference/functions/overview#arrow-operator-and-lambda)."},
+        {"source_arr", "The source array to process. [`Array(T)`](/sql-reference/data-types/array)."},
+        {"[, cond1_arr, ... , condN_arr]", "Optional. N condition arrays providing additional arguments to the lambda function. [`Array(T)`](/sql-reference/data-types/array)."},
+    };
+    FunctionDocumentation::ReturnedValue returned_value_max = "Returns the maximum element in the source array, or the minimum element of the lambda results if provided.";
+    FunctionDocumentation::Examples examples_max = {
+        {"Basic example", "SELECT arrayMax([5, 3, 2, 7]);", "7"},
+        {"Usage with lambda function", "SELECT arrayMax(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);", "12"},
+    };
+    FunctionDocumentation::IntroducedIn introduced_in_max = {21, 1};
+    FunctionDocumentation::Category category_max = FunctionDocumentation::Category::Array;
+    FunctionDocumentation documentation_max = {description_max, syntax_max, arguments_max, returned_value_max, examples_max, introduced_in_max, category_max};
+
+    factory.registerFunction<FunctionArrayMax>(documentation_max);
+
+    FunctionDocumentation::Description description_sum = R"(
+Returns the sum of elements in the source array.
+
+If a lambda function `func` is specified, returns the sum of elements of the lambda results.
+    )";
+    FunctionDocumentation::Syntax syntax_sum = "arrayMax([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])";
+    FunctionDocumentation::Arguments arguments_sum = {
+        {"func(x[, y1, ..., yN])", "Optional. A lambda function which operates on elements of the source array (`x`) and condition arrays (`y`). [Lambda function](/sql-reference/functions/overview#arrow-operator-and-lambda)."},
+        {"source_arr", "The source array to process. [`Array(T)`](/sql-reference/data-types/array)."},
+        {"[, cond1_arr, ... , condN_arr]", "Optional. N condition arrays providing additional arguments to the lambda function. [`Array(T)`](/sql-reference/data-types/array)."},
+    };
+    FunctionDocumentation::ReturnedValue returned_value_sum = "Returns the sum of elements in the source array, or the sum of elements of the lambda results if provided.";
+    FunctionDocumentation::Examples examples_sum = {
+        {"Basic example", "SELECT arraySum([1, 2, 3, 4]);", "10"},
+        {"Usage with lambda function", "SELECT arraySum(x, y -> x+y, [1, 1, 1, 1], [1, 1, 1, 1]);", "8"},
+    };
+    FunctionDocumentation::IntroducedIn introduced_in_sum = {21, 1};
+    FunctionDocumentation::Category category_sum = FunctionDocumentation::Category::Array;
+    FunctionDocumentation documentation_sum = {description_sum, syntax_sum, arguments_sum, returned_value_sum, examples_sum, introduced_in_sum, category_sum};
+
+    factory.registerFunction<FunctionArraySum>(documentation_sum);
+
+    FunctionDocumentation::Description description_avg = R"(
+Returns the average of elements in the source array.
+
+If a lambda function `func` is specified, returns the average of elements of the lambda results.
+    )";
+    FunctionDocumentation::Syntax syntax_avg = "arrayAvg([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])";
+    FunctionDocumentation::Arguments arguments_avg = {
+        {"func(x[, y1, ..., yN])", "Optional. A lambda function which operates on elements of the source array (`x`) and condition arrays (`y`). [Lambda function](/sql-reference/functions/overview#arrow-operator-and-lambda)."},
+        {"source_arr", "The source array to process. [`Array(T)`](/sql-reference/data-types/array)."},
+        {"[, cond1_arr, ... , condN_arr]", "Optional. N condition arrays providing additional arguments to the lambda function. [`Array(T)`](/sql-reference/data-types/array)."},
+    };
+    FunctionDocumentation::ReturnedValue returned_value_avg = "Returns the average of elements in the source array, or the average of elements of the lambda results if provided. [`Float64`](/sql-reference/data-types/float).";
+    FunctionDocumentation::Examples examples_avg = {
+        {"Basic example", "SELECT arrayAvg([1, 2, 3, 4]);", "2.5"},
+        {"Usage with lambda function", "SELECT arrayAvg(x, y -> x*y, [2, 3], [2, 3]) AS res;", "6.5"},
+    };
+    FunctionDocumentation::IntroducedIn introduced_in_avg = {21, 1};
+    FunctionDocumentation::Category category_avg = FunctionDocumentation::Category::Array;
+    FunctionDocumentation documentation_avg = {description_avg, syntax_avg, arguments_avg, returned_value_avg, examples_avg, introduced_in_avg, category_avg};
+
+    factory.registerFunction<FunctionArrayAverage>(documentation_avg);
+
+    FunctionDocumentation::Description description_prod = R"(
+Returns the product of elements in the source array.
+
+If a lambda function `func` is specified, returns the product of elements of the lambda results.
+    )";
+    FunctionDocumentation::Syntax syntax_prod = "arrayProduct([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])";
+    FunctionDocumentation::Arguments arguments_prod = {
+        {"func(x[, y1, ..., yN])", "Optional. A lambda function which operates on elements of the source array (`x`) and condition arrays (`y`). [Lambda function](/sql-reference/functions/overview#arrow-operator-and-lambda)."},
+        {"source_arr", "The source array to process [`Array(T)`](/sql-reference/data-types/array)."},
+        {"[, cond1_arr, ... , condN_arr]", "Optional. N condition arrays providing additional arguments to the lambda function. [`Array(T)`](/sql-reference/data-types/array)."},
+    };
+    FunctionDocumentation::ReturnedValue returned_value_prod = "Returns the product of elements in the source array, or the product of elements of the lambda results if provided. [`Float64`](/sql-reference/data-types/float).";
+    FunctionDocumentation::Examples examples_prod = {
+        {"Basic example", "SELECT arrayProduct([1, 2, 3, 4]);", "24"},
+        {"Usage with lambda function", "SELECT arrayProduct(x, y -> x+y, [2, 2], [2, 2]) AS res;", "16"},
+    };
+    FunctionDocumentation::IntroducedIn introduced_in_prod = {21, 1};
+    FunctionDocumentation::Category category_prod = FunctionDocumentation::Category::Array;
+    FunctionDocumentation documentation_prod = {description_prod, syntax_prod, arguments_prod, returned_value_prod, examples_prod, introduced_in_prod, category_prod};
+
+    factory.registerFunction<FunctionArrayProduct>(documentation_prod);
 }
 
 }

src/Functions/array/arrayAll.cpp

@@ -63,7 +63,25 @@ ColumnPtr ArrayAllImpl::execute(const ColumnArray & array, ColumnPtr mapped)
 
 REGISTER_FUNCTION(ArrayAll)
 {
-    factory.registerFunction<FunctionArrayAll>();
+    FunctionDocumentation::Description description = R"(
+Returns `1` if lambda `func(x [, y1, y2, ... yN])` returns true for all elements. Otherwise, it returns `0`.
+)";
+    FunctionDocumentation::Syntax syntax = "arrayAll(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])";
+    FunctionDocumentation::Arguments arguments = {
+        {"func(x[, y1, ..., yN])", "A lambda function which operates on elements of the source array (`x`) and condition arrays (`y`). [Lambda function](/sql-reference/functions/overview#arrow-operator-and-lambda)."},
+        {"source_arr", "The source array to process. [`Array(T)`](/sql-reference/data-types/array)."},
+        {"[, cond1_arr, ... , condN_arr]", "Optional. N condition arrays providing additional arguments to the lambda function. [`Array(T)`](/sql-reference/data-types/array)."}
+    };
+    FunctionDocumentation::ReturnedValue returned_value = "Returns `1` if the lambda function returns true for all elements, `0` otherwise. [`UInt8`](/sql-reference/data-types/int-uint).";
+    FunctionDocumentation::Examples examples = {
+        {"All elements match", "SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 2, 3])", "1"},
+        {"Not all elements match", "SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 1, 1])", "0"}
+    };
+    FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
+    FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, category};
+
+    factory.registerFunction<FunctionArrayAll>(documentation);
 }
 
 }

src/Functions/array/arrayCount.cpp

@@ -82,7 +82,7 @@ using FunctionArrayCount = FunctionArrayMapped<ArrayCountImpl, NameArrayCount>;
 REGISTER_FUNCTION(ArrayCount)
 {
     FunctionDocumentation::Description description = R"(
-Returns the number of elements for which `func(arr1[i], ..., arrN[i])` returns something other than `0`.
+Returns the number of elements for which `func(arr1[i], ..., arrN[i])` returns true.
 If `func` is not specified, it returns the number of non-zero elements in the array.
 
 `arrayCount` is a [higher-order function](/sql-reference/functions/overview#higher-order-functions).
@@ -92,7 +92,7 @@ If `func` is not specified, it returns the number of non-zero elements in the ar
         {"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::ReturnedValue returned_value = "Returns the number of elements for which `func` returns true. 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"}};
     FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;

src/Functions/array/arrayExists.cpp

@@ -64,7 +64,22 @@ ColumnPtr ArrayExistsImpl::execute(const ColumnArray & array, ColumnPtr mapped)
 
 REGISTER_FUNCTION(ArrayExists)
 {
-    factory.registerFunction<FunctionArrayExists>();
+    FunctionDocumentation::Description description = R"(
+Returns `1` if there is at least one element in a source array for which `func(x[, y1, y2, ... yN])` returns true. Otherwise, it returns `0`.
+)";
+    FunctionDocumentation::Syntax syntax = "arrayExists(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])";
+    FunctionDocumentation::Arguments arguments = {
+        {"func(x[, y1, ..., yN])", "A lambda function which operates on elements of the source array (`x`) and condition arrays (`y`). [Lambda function](/sql-reference/functions/overview#arrow-operator-and-lambda)."},
+        {"source_arr", "The source array to process. [`Array(T)`](/sql-reference/data-types/array)."},
+        {"[, cond1_arr, ... , condN_arr]", "Optional. N condition arrays providing additional arguments to the lambda function. [`Array(T)`](/sql-reference/data-types/array)."}
+    };
+    FunctionDocumentation::ReturnedValue returned_value = "Returns `1` if the lambda function returns true for at least one element, `0` otherwise. [`UInt8`](/sql-reference/data-types/int-uint).";
+    FunctionDocumentation::Examples examples = {{"Usage example", "SELECT arrayExists(x, y -> x=y, [1, 2, 3], [0, 0, 0])", "0"}};
+    FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
+    FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, category};
+
+    factory.registerFunction<FunctionArrayExists>(documentation);
 }
 
 }

src/Functions/array/arrayFill.cpp

@@ -136,11 +136,11 @@ position i, the function replaces that element with the element at position i-1
 from the current state of the array. The first element is always preserved
 regardless of any condition.
 )";
-    FunctionDocumentation::Syntax syntax = "arrayFill(func(x [, y1, ..., yN]), source [, cond1, ... , condN])";
+    FunctionDocumentation::Syntax syntax = "arrayFill(func(x [, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])";
     FunctionDocumentation::Arguments arguments = {
         {"func(x [, y1, ..., yN])", "A lambda function `func(x [, y1, y2, ... yN]) → F(x [, y1, y2, ... yN])` which operates on elements of the source array (`x`) and condition arrays (`y`). [Lambda function](/sql-reference/functions/overview#arrow-operator-and-lambda)."},
-        {"source", "The source array to process [`Array(T)`](/sql-reference/data-types/array)."},
-        {"[, cond1, ... , condN]", "Optional. N condition arrays providing additional arguments to the lambda function. [`Array(T)`](/sql-reference/data-types/array)."},
+        {"source_arr", "The source array to process [`Array(T)`](/sql-reference/data-types/array)."},
+        {"[, cond1_arr, ... , condN_arr]", "Optional. N condition arrays providing additional arguments to the lambda function. [`Array(T)`](/sql-reference/data-types/array)."},
     };
     FunctionDocumentation::ReturnedValue returned_value = "Returns an array. [`Array(T)`](/sql-reference/data-types/array).";
     FunctionDocumentation::Examples examples = {
@@ -161,11 +161,11 @@ position i, the function replaces that element with the element at position i+1
 from the current state of the array. The last element is always preserved
 regardless of any condition.
     )";
-    FunctionDocumentation::Syntax syntax_reverse = "arrayReverseFill(func(x[, y1, ..., yN]), source[, cond1, ... , condN])";
+    FunctionDocumentation::Syntax syntax_reverse = "arrayReverseFill(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])";
     FunctionDocumentation::Arguments arguments_reverse = {
         {"func(x[, y1, ..., yN])", "A lambda function which operates on elements of the source array (`x`) and condition arrays (`y`). [Lambda function](/sql-reference/functions/overview#arrow-operator-and-lambda)."},
-        {"source", "The source array to process [`Array(T)`](/sql-reference/data-types/array)."},
-        {"[, cond1, ... , condN]", "Optional. N condition arrays providing additional arguments to the lambda function. [`Array(T)`](/sql-reference/data-types/array)."},
+        {"source_arr", "The source array to process [`Array(T)`](/sql-reference/data-types/array)."},
+        {"[, cond1_arr, ... , condN_arr]", "Optional. N condition arrays providing additional arguments to the lambda function. [`Array(T)`](/sql-reference/data-types/array)."},
     };
     FunctionDocumentation::ReturnedValue returned_value_reverse = "Returns an array with elements of the source array replaced by the results of the lambda. [`Array(T)`](/sql-reference/data-types/array).";
     FunctionDocumentation::Examples examples_reverse = {

src/Functions/array/arrayFilter.cpp

@@ -49,12 +49,12 @@ ColumnPtr ArrayFilterImpl::execute(const ColumnArray & array, ColumnPtr mapped)
 
 REGISTER_FUNCTION(ArrayFilter)
 {
-    FunctionDocumentation::Description description = "Returns an array containing only the elements in the source array for which a lambda function returns something other than `0`.";
-    FunctionDocumentation::Syntax syntax = "arrayFilter(func(x[, y1, ..., yN]), source[, cond1, ... , condN])]";
+    FunctionDocumentation::Description description = "Returns an array containing only the elements in the source array for which a lambda function returns true.";
+    FunctionDocumentation::Syntax syntax = "arrayFilter(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])]";
     FunctionDocumentation::Arguments arguments = {
         {"func(x[, y1, ..., yN])", "A lambda function which operates on elements of the source array (`x`) and condition arrays (`y`). [Lambda function](/sql-reference/functions/overview#arrow-operator-and-lambda)."},
-        {"source", "The source array to process [`Array(T)`](/sql-reference/data-types/array)."},
-        {"[, cond1, ... , condN]", "Optional. N condition arrays providing additional arguments to the lambda function. [`Array(T)`](/sql-reference/data-types/array)."},
+        {"source_arr", "The source array to process [`Array(T)`](/sql-reference/data-types/array)."},
+        {"[, cond1_arr, ... , condN_arr]", "Optional. N condition arrays providing additional arguments to the lambda function. [`Array(T)`](/sql-reference/data-types/array)."},
     };
     FunctionDocumentation::ReturnedValue returned_value = "Returns a subset of the source array. [`Array(T)`](/sql-reference/data-types/array).";
     FunctionDocumentation::Examples examples = {