Autogen functions formatting improvements

Author: Blargian

src/Common/FunctionDocumentation.cpp

@@ -27,14 +27,13 @@ std::string FunctionDocumentation::examplesAsString() const
     std::string res;
     for (const auto & [name, query, result] : examples)
     {
-        res += name + ":\n\n";
-        res += "```sql\n";
+        res += "**" + name + "**" + "\n\n";
+        res += "```sql title=""Query""\n";
         res += query + "\n";
         res += "```\n\n";
-        res += "Result:\n\n";
-        res += "```text\n";
+        res += "```response title=""Response""\n";
         res += result + "\n";
-        res += "```\n";
+        res += "```";
     }
     return res;
 }

src/Functions/modulo.cpp

@@ -201,8 +201,8 @@ Calculates the remainder when dividing `x` by `y`. Similar to function
 `modulo` except that `positiveModulo` always return non-negative number.
     )";
     FunctionDocumentation::Syntax syntax = "positiveModulo(x, y)";
-    FunctionDocumentation::Argument argument1 = {"x", "The dividend"};
-    FunctionDocumentation::Argument argument2 = {"y", "The divisor (modulus)"};
+    FunctionDocumentation::Argument argument1 = {"x", "The dividend. [`(U)Int*`](/sql-reference/data-types/int-uint)/[`Float32/64`](/sql-reference/data-types/float)."};
+    FunctionDocumentation::Argument argument2 = {"y", "The divisor (modulus). [`(U)Int*`](/sql-reference/data-types/int-uint)/[`Float32/64`](/sql-reference/data-types/float)."};
     FunctionDocumentation::Arguments arguments = {argument1, argument2};
     FunctionDocumentation::ReturnedValue returned_value = R"(
 Returns the difference between `x` and the nearest integer not greater than

src/Functions/moduloOrNull.cpp

@@ -21,15 +21,25 @@ using FunctionPositiveModuloOrNll = BinaryArithmeticOverloadResolver<PositiveMod
 
 REGISTER_FUNCTION(PositiveModuloOrNull)
 {
-    factory.registerFunction<FunctionPositiveModuloOrNll>(FunctionDocumentation
-        {
-            .description = R"(
+    FunctionDocumentation::Description description = R"(
 Calculates the remainder when dividing `a` by `b`. Similar to function `positiveModulo` except that `positiveModuloOrNull` will return NULL
 if the right argument is 0.
-        )",
-            .examples{{"positiveModuloOrNull", "SELECT positiveModuloOrNull(1, 0);", ""}},
-            .category = FunctionDocumentation::Category::Arithmetic},
-        FunctionFactory::Case::Insensitive);
+    )";
+    FunctionDocumentation::Syntax syntax = "positiveModulo(x, y)";
+    FunctionDocumentation::Arguments arguments = {
+        {"x", "The dividend. [`(U)Int*`](/sql-reference/data-types/int-uint)/[`Float32/64`](/sql-reference/data-types/float)."},
+        {"x", "The divisor (modulus). [`(U)Int*`](/sql-reference/data-types/int-uint)/[`Float32/64`](/sql-reference/data-types/float)."}
+    };
+    FunctionDocumentation::ReturnedValue returned_value = R"(
+Returns the difference between `x` and the nearest integer not greater than
+`x` divisible by `y`, `null` when the divisor is zero.
+    )";
+    FunctionDocumentation::Examples examples = {{"positiveModulo", "SELECT positiveModulo(-1, 10)", "9"}};
+    FunctionDocumentation::IntroducedIn introduced_in = {22, 11};
+    FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
+
+    factory.registerFunction<FunctionPositiveModuloOrNll>(documentation, FunctionFactory::Case::Insensitive);
 
     factory.registerAlias("positive_modulo_or_null", "positiveModuloOrNull", FunctionFactory::Case::Insensitive);
     factory.registerAlias("pmodOrNull", "positiveModuloOrNull", FunctionFactory::Case::Insensitive);

src/Functions/moduloOrZero.cpp

@@ -48,16 +48,16 @@ Like modulo but returns zero when the divisor is zero, as opposed to an
 exception with the modulo function.
     )";
     FunctionDocumentation::Syntax syntax = "moduloOrZero(a, b)";
-    FunctionDocumentation::Argument argument1 = {"a", "The dividend"};
-    FunctionDocumentation::Argument argument2 = {"b", "The divisor (modulus)"};
+    FunctionDocumentation::Argument argument1 = {"a", "The dividend. [`(U)Int*`](/sql-reference/data-types/int-uint)/[`Float32/64`](/sql-reference/data-types/float)."};
+    FunctionDocumentation::Argument argument2 = {"b", "The divisor (modulus). [`(U)Int*`](/sql-reference/data-types/int-uint)/[`Float32/64`](/sql-reference/data-types/float)."};
     FunctionDocumentation::Arguments arguments = {argument1, argument2};
     FunctionDocumentation::ReturnedValue returned_value = "The remainder of a % b, or `0` when the divisor is `0`.";
     FunctionDocumentation::Examples examples = {{"", "SELECT moduloOrZero(5, 0)", "0"}};
     FunctionDocumentation::IntroducedIn introduced_in = {20, 3};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
     FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
 
-    factory.registerFunction<FunctionModuloOrZero>();
+    factory.registerFunction<FunctionModuloOrZero>(documentation);
 }
 
 }