Fix style check

Author: Blargian

src/Functions/array/arrayIntersect.cpp

@@ -766,18 +766,16 @@ 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::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"(
+    FunctionDocumentation::Examples intersect_example = {{"Usage example",
+R"(
 SELECT
 arrayIntersect([1, 2], [1, 3], [2, 3]) AS empty_intersection,
 arrayIntersect([1, 2], [1, 3], [1, 4]) AS non_empty_intersection
-	)", R"(
+)", R"(
 ┌─non_empty_intersection─┬─empty_intersection─┐
 │ []                     │ [1]                │
 └────────────────────────┴────────────────────┘
@@ -791,22 +789,22 @@ arrayIntersect([1, 2], [1, 3], [1, 4]) AS non_empty_intersection
     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::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::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"(
+    FunctionDocumentation::Examples union_example = {{"Usage example",
+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] │
 └─────────────┴────────────────┴──────────────┘
-	)"}};
+)"}};
     FunctionDocumentation::IntroducedIn union_introduced_in = {24, 10};
     FunctionDocumentation::Category union_category = FunctionDocumentation::Category::Array;
     FunctionDocumentation union_documentation = {union_description, union_syntax, union_argument, union_returned_value, union_example, union_introduced_in, union_category};
@@ -821,21 +819,20 @@ The symmetric difference of _more than two sets_ is [mathematically defined](htt
 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::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
 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]                            │
 └────────────────────────────┴────────────────────────────────┘
-	)"}};
+)"}};
     FunctionDocumentation::IntroducedIn symdiff_introduced_in = {25, 4};
     FunctionDocumentation::Category symdiff_category = FunctionDocumentation::Category::Array;
     FunctionDocumentation symdiff_documentation = {symdiff_description, symdiff_syntax, symdiff_argument, symdiff_returned_value, symdiff_example, symdiff_introduced_in, symdiff_category};

src/Functions/array/arrayUniq.cpp

@@ -319,7 +319,7 @@ 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.
@@ -333,15 +333,15 @@ It will then count the number of unique tuples. In this case `2`.
 :::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(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)."}
+		{"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::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"},
+		{"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};