Update

rschu1ze · rschu1ze · commit 966455963d32 · 2025-05-06T11:58:13.000Z
diff --git a/src/Functions/abs.cpp b/src/Functions/abs.cpp
@@ -56,8 +56,9 @@ REGISTER_FUNCTION(Abs)
     FunctionDocumentation::Arguments argument = {{"x", "Value to get the absolute value of"}};
     FunctionDocumentation::ReturnedValue returned_value = "The absolute value of `x`";
     FunctionDocumentation::Examples examples = {{"", "SELECT abs(-0.5)", "0.5"}};
+    FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, argument, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, argument, returned_value, examples, introduced_in, categories};
 
     factory.registerFunction<FunctionAbs>(documentation, FunctionFactory::Case::Insensitive);
 }
diff --git a/src/Functions/byteSwap.cpp b/src/Functions/byteSwap.cpp
@@ -88,8 +88,9 @@ One use case of this function is reversing IPv4s:
     FunctionDocumentation::Example example4 = {"32-bit", "SELECT byteSwap(3351772109)", "3455829959"};
     FunctionDocumentation::Example example5 = {"64-bit", "SELECT byteSwap(123294967295)", "18439412204227788800"};
     FunctionDocumentation::Examples examples = {example1, example2, example3, example4, example5};
+    FunctionDocumentation::IntroducedIn introduced_in = {23, 10};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
     factory.registerFunction<FunctionByteSwap>(documentation,FunctionFactory::Case::Insensitive);
 }
 
diff --git a/src/Functions/divide.cpp b/src/Functions/divide.cpp
@@ -57,8 +57,9 @@ REGISTER_FUNCTION(Divide)
     FunctionDocumentation::Example example1 = {"Dividing two numbers", "SELECT divide(25,5) AS quotient, toTypeName(quotient)", "5 Float64"};
     FunctionDocumentation::Example example2 = {"Dividing by zero", "SELECT divide(25,0)", "inf"};
     FunctionDocumentation::Examples examples = {example1, example2};
+    FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
 
     factory.registerFunction<FunctionDivide>(documentation);
 }
diff --git a/src/Functions/divideDecimal.cpp b/src/Functions/divideDecimal.cpp
@@ -93,8 +93,9 @@ SELECT toDecimal64(-12, 1) as a, toDecimal32(2.1, 1) as b, divideDecimal(a, b, 1
 └─────┴─────┴────────────────────────────────────────────────────────────┴────────────────────────────────────────────────────────────┘
     )"};
     FunctionDocumentation::Examples examples = {example1, example2};
+    FunctionDocumentation::IntroducedIn introduced_in = {22, 12};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
     factory.registerFunction<FunctionsDecimalArithmetics<DivideDecimalsImpl>>(documentation);
 }
 
diff --git a/src/Functions/gcd.cpp b/src/Functions/gcd.cpp
@@ -44,8 +44,9 @@ REGISTER_FUNCTION(GCD)
     FunctionDocumentation::ReturnedValue returned_value = "The greatest common divisor of `x` and `y`.";
     FunctionDocumentation::Example example1 = {"", "SELECT gcd(12, 18)", "6"};
     FunctionDocumentation::Examples examples = {example1};
+    FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
 
     factory.registerFunction<FunctionGCD>(documentation);
 }
diff --git a/src/Functions/ifNotFinite.cpp b/src/Functions/ifNotFinite.cpp
@@ -80,8 +80,9 @@ You can get a similar result by using the [ternary operator](/sql-reference/func
 - `y` if `x` is not finite.
     )";
     FunctionDocumentation::Examples examples = {{"","SELECT 1/0 AS infimum, ifNotFinite(infimum,42)","inf  42"}};
+    FunctionDocumentation::IntroducedIn introduced_in = {20, 3};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
 
     factory.registerFunction<FunctionIfNotFinite>(documentation);
 }
diff --git a/src/Functions/intDiv.cpp b/src/Functions/intDiv.cpp
@@ -158,8 +158,9 @@ large number: While processing intDiv(1, 0.001) AS res, toTypeName(res).
         )"
     };
     FunctionDocumentation::Examples examples = {example1, example2};
+    FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
 
     factory.registerFunction<FunctionIntDiv>(documentation);
 }
diff --git a/src/Functions/intDivOrZero.cpp b/src/Functions/intDivOrZero.cpp
@@ -43,8 +43,9 @@ minimal negative number by minus one.
     FunctionDocumentation::Example example1 = {"Integer division by zero", "SELECT intDivOrZero(1, 0)","0"};
     FunctionDocumentation::Example example2 = {"Dividing a minimal negative number by minus 1", "SELECT intDivOrZero(0.05, -1)","0"};
     FunctionDocumentation::Examples examples = {example1, example2};
+    FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
 
     factory.registerFunction<FunctionIntDivOrZero>(documentation);
 }
diff --git a/src/Functions/isFinite.cpp b/src/Functions/isFinite.cpp
@@ -49,8 +49,9 @@ otherwise this function returns `0`.
     FunctionDocumentation::Arguments arguments = {argument1};
     FunctionDocumentation::ReturnedValue returned_value = "`1` if x is not infinite and not `NaN`, otherwise `0`.";
     FunctionDocumentation::Examples examples = {{"Test if a number is finite", "SELECT isFinite(inf)", "0"}};
+    FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
 
     factory.registerFunction<FunctionIsFinite>(documentation);
 }
diff --git a/src/Functions/isInfinite.cpp b/src/Functions/isInfinite.cpp
@@ -44,10 +44,10 @@ REGISTER_FUNCTION(IsInfinite)
     FunctionDocumentation::Argument argument1 = {"x", "Number to check for infiniteness. Float32 or Float64."};
     FunctionDocumentation::Arguments arguments = {argument1};
     FunctionDocumentation::ReturnedValue returned_value = "`1` if x is infinite, otherwise `0` (including for `NaN`).";
-    FunctionDocumentation::Examples examples = {{"Test if a number is infinite", "SELECT isInfinite(inf), isInfinite(NaN), isInfinite(10))", "1 0 0"}
-    };
+    FunctionDocumentation::Examples examples = {{"Test if a number is infinite", "SELECT isInfinite(inf), isInfinite(NaN), isInfinite(10))", "1 0 0"}};
+    FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
 
     factory.registerFunction<FunctionIsInfinite>(documentation);
 }
diff --git a/src/Functions/isNaN.cpp b/src/Functions/isNaN.cpp
@@ -29,8 +29,9 @@ REGISTER_FUNCTION(IsNaN)
     FunctionDocumentation::Arguments arguments = {argument1};
     FunctionDocumentation::ReturnedValue returned_value = "`1` if `NaN`, otherwise `0`";
     FunctionDocumentation::Examples examples = {{"", "SELECT isNaN(NaN)", "1"}};
+    FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
 
     factory.registerFunction<FunctionIsNaN>(documentation);
 }
diff --git a/src/Functions/lcm.cpp b/src/Functions/lcm.cpp
@@ -75,8 +75,9 @@ An exception is thrown when dividing by zero or when dividing a minimal negative
     FunctionDocumentation::ReturnedValue returned_value = "The least common multiple of `x` and `y`.";
     FunctionDocumentation::Example example1 = {"", "SELECT lcm(6, 8)", "24"};
     FunctionDocumentation::Examples examples = {example1};
+    FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
 
     factory.registerFunction<FunctionLCM>(documentation);
 }
diff --git a/src/Functions/max2.cpp b/src/Functions/max2.cpp
@@ -30,8 +30,9 @@ REGISTER_FUNCTION(Max2)
     FunctionDocumentation::Arguments arguments = {argument1, argument2};
     FunctionDocumentation::ReturnedValue returned_value = "Returns the bigger value of `x` and `y`";
     FunctionDocumentation::Examples examples = {{"", "SELECT max2(-1, 2)", "2"}};
+    FunctionDocumentation::IntroducedIn introduced_in = {21, 11};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
 
     factory.registerFunction<FunctionMax2>(documentation, FunctionFactory::Case::Insensitive);
 }
diff --git a/src/Functions/min2.cpp b/src/Functions/min2.cpp
@@ -32,8 +32,9 @@ REGISTER_FUNCTION(Min2)
     FunctionDocumentation::ReturnedValue returned_value = "Returns the smaller value of `x` and `y`";
     FunctionDocumentation::Example example1 = {"", "SELECT min2(-1, 2)", "-1"};
     FunctionDocumentation::Examples examples = {example1};
+    FunctionDocumentation::IntroducedIn introduced_in = {21, 11};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
 
     factory.registerFunction<FunctionMin2>(documentation, FunctionFactory::Case::Insensitive);
 }
diff --git a/src/Functions/minus.cpp b/src/Functions/minus.cpp
@@ -61,8 +61,9 @@ Additionally, subtraction between date with time is supported, resulting in the
     FunctionDocumentation::Example example1 = {"Subtracting two numbers", "SELECT minus(10,5)", "5"};
     FunctionDocumentation::Example example2 = {"Subtracting an integer and a date", "SELECT minus(toDate('2025-01-01'),5)", "2024-12-27"};
     FunctionDocumentation::Examples examples = {example1, example2};
+    FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
 
     factory.registerFunction<FunctionMinus>(documentation);
 }
diff --git a/src/Functions/modulo.cpp b/src/Functions/modulo.cpp
@@ -173,8 +173,9 @@ REGISTER_FUNCTION(Modulo)
     FunctionDocumentation::ReturnedValue returned_value = "The remainder of a % b";
     FunctionDocumentation::Example example1 = {"", "SELECT modulo(5, 2)", "1"};
     FunctionDocumentation::Examples examples = {example1};
+    FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
     factory.registerFunction<FunctionModulo>(documentation);
     factory.registerAlias("mod", "modulo", FunctionFactory::Case::Insensitive);
 }
@@ -209,8 +210,9 @@ Returns the difference between `x` and the nearest integer not greater than
     )";
     FunctionDocumentation::Example example1 = {"positiveModulo", "SELECT positiveModulo(-1, 10)", "9"};
     FunctionDocumentation::Examples examples = {example1};
+    FunctionDocumentation::IntroducedIn introduced_in = {22, 11};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
     factory.registerFunction<FunctionPositiveModulo>(documentation,
         FunctionFactory::Case::Insensitive);
 
diff --git a/src/Functions/moduloOrZero.cpp b/src/Functions/moduloOrZero.cpp
@@ -53,8 +53,9 @@ exception with the modulo function.
     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, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
 
     factory.registerFunction<FunctionModuloOrZero>();
 }
diff --git a/src/Functions/multiply.cpp b/src/Functions/multiply.cpp
@@ -62,8 +62,9 @@ REGISTER_FUNCTION(Multiply)
     FunctionDocumentation::Arguments arguments = {argument1, argument2};
     FunctionDocumentation::ReturnedValue returned_value = "The product of x and y";
     FunctionDocumentation::Examples examples = {{"Multiplying two numbers", "SELECT multiply(5,5)", "25"}};
+    FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
 
     factory.registerFunction<FunctionMultiply>(documentation);
 }
diff --git a/src/Functions/multiplyDecimal.cpp b/src/Functions/multiplyDecimal.cpp
@@ -101,8 +101,9 @@ Code: 407. DB::Exception: Received from localhost:9000. DB::Exception: Decimal m
 While processing toDecimal64(-12.647987876, 9) AS a, toDecimal64(123.967645643, 9) AS b, a * b. (DECIMAL_OVERFLOW)
     )"};
     FunctionDocumentation::Examples examples = {example1, example2, example3};
+    FunctionDocumentation::IntroducedIn introduced_in = {22, 12};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
 
     factory.registerFunction<FunctionsDecimalArithmetics<MultiplyDecimalsImpl>>(documentation);
 }
diff --git a/src/Functions/negate.cpp b/src/Functions/negate.cpp
@@ -87,8 +87,9 @@ REGISTER_FUNCTION(Negate)
     FunctionDocumentation::ReturnedValue returned_value = "Returns -x from x";
     FunctionDocumentation::Example example1 = {"", "SELECT negate(10)", "-10"};
     FunctionDocumentation::Examples examples = {example1};
+    FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
 
     factory.registerFunction<FunctionNegate>(documentation);
 }
diff --git a/src/Functions/plus.cpp b/src/Functions/plus.cpp
@@ -65,7 +65,8 @@ increments the number of seconds in the date with time.
     FunctionDocumentation::Example example2 = {"Adding an integer and a date", "SELECT plus(toDate('2025-01-01'),5)", "2025-01-06"};
     FunctionDocumentation::Examples examples = {example1, example2};
     FunctionDocumentation::Category categories = FunctionDocumentation::Category::Arithmetic;
-    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, categories};
+    FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
+    FunctionDocumentation documentation = {description, syntax, arguments, returned_value, examples, introduced_in, categories};
 
     factory.registerFunction<FunctionPlus>(documentation);
 }
diff --git a/tests/queries/0_stateless/02415_all_new_functions_must_have_version_information.sql b/tests/queries/0_stateless/02415_all_new_functions_must_have_version_information.sql
@@ -15,5 +15,8 @@ AND name NOT IN (
     'geoToS2', 's2CapContains', 's2CapUnion', 's2CellsIntersect', 's2GetNeighbors', 's2RectAdd', 's2RectContains', 's2RectIntersection', 's2RectUnion', 's2ToGeo',
     'normalizeUTF8NFC', 'normalizeUTF8NFD', 'normalizeUTF8NFKC', 'normalizeUTF8NFKD',
     'lemmatize', 'tokenize', 'stem', 'synonyms', 'kql_array_sort_asc', 'kql_array_sort_desc',
-    'detectCharset', 'detectLanguageUnknown', 'detectProgrammingLanguage', 'detectTonality'
+    'detectCharset', 'detectLanguageUnknown', 'detectProgrammingLanguage', 'detectTonality',
+    'BLAKE3', 'JSONMergePatch', 'MD4', 'MD5', 'RIPEMD160', 'SHA1', 'SHA224', 'SHA256', 'SHA384', 'SHA512', 'SHA512_256', 'ULIDStringToDateTime', 'generateULID', 'halfMD5',
+    'idnaDecode', 'idnaEncode', 'keccak256', 'punycodeDecode', 'punycodeEncode', 'seriesPeriodDetectFFT', 'sqidDecode', 'sqidEncode', 'tryDecrypt', 'tryIdnaEncode', 'tryPunycodeDecode', 'uniqThetaIntersect',
+    'uniqThetaNot', 'uniqThetaUnion'
 ) ORDER BY name;
