Fix style

Author: Blargian

src/Functions/array/arrayIntersect.cpp

@@ -766,41 +766,35 @@ 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::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::Examples intersect_example = {{"Usage example",
-R"(
-SELECT
+R"(SELECT
 arrayIntersect([1, 2], [1, 3], [2, 3]) AS empty_intersection,
 arrayIntersect([1, 2], [1, 3], [1, 4]) AS non_empty_intersection
 )", R"(
 ┌─non_empty_intersection─┬─empty_intersection─┐
 │ []                     │ [1]                │
 └────────────────────────┴────────────────────┘
-	)"}};
+)"}};
     FunctionDocumentation::IntroducedIn intersect_introduced_in = {1, 1};
     FunctionDocumentation::Category intersect_category = FunctionDocumentation::Category::Array;
     FunctionDocumentation intersect_documentation = {intersect_description, intersect_syntax, intersect_argument, intersect_returned_value, intersect_example, intersect_introduced_in, intersect_category};
 
     factory.registerFunction<ArrayIntersect>(intersect_documentation);
 
-    FunctionDocumentation::Description union_description = R"(
-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::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::Examples union_example = {{"Usage example",
-R"(
-SELECT
+R"(SELECT
 arrayUnion([-2, 1], [10, 1], [-2], []) as num_example,
 arrayUnion(['hi'], [], ['hello', 'hi']) as str_example,
 arrayUnion([1, 3, NULL], [2, 3, NULL]) as null_example
-)",
-R"(
+)",R"(
 ┌─num_example─┬─str_example────┬─null_example─┐
 │ [10,-2,1]   │ ['hello','hi'] │ [3,2,1,NULL] │
 └─────────────┴────────────────┴──────────────┘
@@ -811,8 +805,7 @@ R"(
 
     factory.registerFunction<ArrayUnion>(union_documentation);
 
-    FunctionDocumentation::Description symdiff_description = R"(
-Takes multiple arrays and returns an array with elements that are not present in all source arrays. The result contains only unique values.
+    FunctionDocumentation::Description symdiff_description = R"(Takes multiple arrays and returns an array with elements that are not present in all source arrays. The result contains only unique values.
 
 :::note
 The symmetric difference of _more than two sets_ is [mathematically defined](https://en.wikipedia.org/wiki/Symmetric_difference#n-ary_symmetric_difference)
@@ -822,13 +815,11 @@ In contrast, function `arraySymmetricDifference` simply returns the set of input
 )";
     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 distinct elements not present in all source arrays. [`Array`](/sql-reference/data-types/array).";
-    FunctionDocumentation::Examples symdiff_example = {{"Usage example", R"(
-SELECT
+    FunctionDocumentation::ReturnedValue symdiff_returned_value = "Returns an array of distinct elements not present in all source arrays. [`Array`](/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;
-)",
-R"(
+)", R"(
 ┌─empty_symmetric_difference─┬─non_empty_symmetric_difference─┐
 │ []                         │ [3]                            │
 └────────────────────────────┴────────────────────────────────┘

src/Functions/array/arrayUniq.cpp

@@ -319,9 +319,8 @@ void FunctionArrayUniq::executeHashed(
 
 REGISTER_FUNCTION(ArrayUniq)
 {
-	FunctionDocumentation::Description description = R"(
+    FunctionDocumentation::Description description = R"(
 For a single argument passed, counts the number of different elements in the array.
-
 For multiple arguments passed, it counts the number of different **tuples** made of elements at matching positions across multiple arrays.
 
 For example `SELECT arrayUniq([1,2], [3,4], [5,6])` will form the following tuples:
@@ -334,16 +333,26 @@ It will then count the number of unique tuples. In this case `2`.
 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(x[, ...yN])";
     FunctionDocumentation::Arguments arguments = {
-		{"x", "Array for which to count the number of unique elements. [`Array`](/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)."}
-    };
-	FunctionDocumentation::ReturnedValue returned_value = "For a single arguments returns the number of unique elements. For multiple arguments returns the number of unique tuples made from elements at corresponding positions across the arrays. [`UInt32`](/sql-reference/data-types/int-uint)";
-    FunctionDocumentation::Examples examples = {
-		{"Single argument", "SELECT arrayUniq([1,1,2,2])", "2"},
-        {"Multiple argument", "SELECT arrayUniq([1,2,3], [4,5,6])", "3"}
+        {
+            "x",
+            "Array for which to count the number of unique elements. [`Array`](/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)."
+        }
     };
+	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
+elements at corresponding positions across the arrays.
+[`UInt32`](/sql-reference/data-types/int-uint).
+)";
+    FunctionDocumentation::Examples examples =
+{{"Single argument", "SELECT arrayUniq([1,1,2,2])", "2"},
+{"Multiple argument", "SELECT arrayUniq([1,2,3], [4,5,6])", "3"}};
     FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;
     FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, category};