diff --git a/be/src/vec/functions/math.cpp b/be/src/vec/functions/math.cpp index 6e8222bae4b6f94..c4d5f8ed6aaef7e 100644 --- a/be/src/vec/functions/math.cpp +++ b/be/src/vec/functions/math.cpp @@ -60,6 +60,13 @@ struct AcosName { using FunctionAcos = FunctionMathUnaryAlwayNullable>; +struct AcoshName { + static constexpr auto name = "acosh"; + static constexpr bool is_invalid_input(Float64 x) { return x < 1; } +}; +using FunctionAcosh = + FunctionMathUnaryAlwayNullable>; + struct AsinName { static constexpr auto name = "asin"; // https://dev.mysql.com/doc/refman/8.4/en/mathematical-functions.html#function_asin @@ -68,11 +75,23 @@ struct AsinName { using FunctionAsin = FunctionMathUnaryAlwayNullable>; +struct AsinhName { + static constexpr auto name = "asinh"; +}; +using FunctionAsinh = FunctionMathUnary>; + struct AtanName { static constexpr auto name = "atan"; }; using FunctionAtan = FunctionMathUnary>; +struct AtanhName { + static constexpr auto name = "atanh"; + static constexpr bool is_invalid_input(Float64 x) { return x <= -1 || x >= 1; } +}; +using FunctionAtanh = + FunctionMathUnaryAlwayNullable>; + template struct Atan2Impl { using ResultType = double; @@ -247,6 +266,11 @@ struct UnaryFunctionPlainSin { using FunctionSin = FunctionMathUnary; +struct SinhName { + static constexpr auto name = "sinh"; +}; +using FunctionSinh = FunctionMathUnary>; + struct SqrtName { static constexpr auto name = "sqrt"; // https://dev.mysql.com/doc/refman/8.4/en/mathematical-functions.html#function_sqrt @@ -427,8 +451,11 @@ class FunctionNormalCdf : public IFunction { // so mush. Split it to speed up compile time in the future void register_function_math(SimpleFunctionFactory& factory) { factory.register_function(); + factory.register_function(); factory.register_function(); + factory.register_function(); factory.register_function(); + factory.register_function(); factory.register_function(); factory.register_function(); factory.register_function(); @@ -445,6 +472,7 @@ void register_function_math(SimpleFunctionFactory& factory) { factory.register_function(); factory.register_function(); factory.register_function(); + factory.register_function(); factory.register_function(); factory.register_alias("sqrt", "dsqrt"); factory.register_function(); diff --git a/be/test/vec/function/function_math_test.cpp b/be/test/vec/function/function_math_test.cpp index bb24d141e4c3be5..070e1ac095b2c59 100644 --- a/be/test/vec/function/function_math_test.cpp +++ b/be/test/vec/function/function_math_test.cpp @@ -43,6 +43,20 @@ TEST(MathFunctionTest, acos_test) { static_cast(check_function(func_name, input_types, data_set)); } +TEST(MathFunctionTest, acosh_test) { + std::string func_name = "acosh"; // acosh(x) = ln(x + sqrt(x^2 - 1)), x ∈ [1, +∞) + + InputTypeSet input_types = {TypeIndex::Float64}; + + DataSet data_set = {{{1.0}, 0.0}, + {{2.0}, 1.3169578969248168}, + {{3.0}, 1.7627471740390861}, + {{10.0}, 2.9932228461263808}, + {{100.0}, 5.2982923656104850}}; + + static_cast(check_function(func_name, input_types, data_set)); +} + TEST(MathFunctionTest, asin_test) { std::string func_name = "asin"; //[-1,1] -->[-pi_2, pi_2] @@ -54,6 +68,20 @@ TEST(MathFunctionTest, asin_test) { static_cast(check_function(func_name, input_types, data_set)); } +TEST(MathFunctionTest, asinh_test) { + std::string func_name = "asinh"; // asinh(x) = ln(x + sqrt(x^2 + 1)), x ∈ (-∞, +∞) + + InputTypeSet input_types = {TypeIndex::Float64}; + + DataSet data_set = {{{0.0}, 0.0}, + {{1.0}, 0.8813735870195430}, + {{-1.0}, -0.8813735870195430}, + {{2.0}, 1.4436354751788103}, + {{-2.0}, -1.4436354751788103}}; + + static_cast(check_function(func_name, input_types, data_set)); +} + TEST(MathFunctionTest, atan_test) { std::string func_name = "atan"; //[-,+] -->(pi_2,pi_2) @@ -67,6 +95,20 @@ TEST(MathFunctionTest, atan_test) { static_cast(check_function(func_name, input_types, data_set)); } +TEST(MathFunctionTest, atanh_test) { + std::string func_name = "atanh"; // atanh(x) = 0.5 * ln((1 + x) / (1 - x)), x ∈ (-1, 1) + + InputTypeSet input_types = {TypeIndex::Float64}; + + DataSet data_set = {{{0.0}, 0.0}, + {{0.5}, 0.5493061443340549}, + {{-0.5}, -0.5493061443340549}, + {{0.9}, 1.4722194895832204}, + {{-0.9}, -1.4722194895832204}}; + + static_cast(check_function(func_name, input_types, data_set)); +} + TEST(MathFunctionTest, cos_test) { std::string func_name = "cos"; @@ -95,6 +137,20 @@ TEST(MathFunctionTest, sin_test) { static_cast(check_function(func_name, input_types, data_set)); } +TEST(MathFunctionTest, sinh_test) { + std::string func_name = "sinh"; // sinh(x) = (e^x - e^(-x)) / 2, x ∈ (-∞, +∞) + + InputTypeSet input_types = {TypeIndex::Float64}; + + DataSet data_set = {{{0.0}, 0.0}, + {{1.0}, 1.1752011936438014}, + {{-1.0}, -1.1752011936438014}, + {{2.0}, 3.6268604078470186}, + {{-2.0}, -3.6268604078470186}}; + + static_cast(check_function(func_name, input_types, data_set)); +} + TEST(MathFunctionTest, sqrt_test) { std::string func_name = "sqrt"; //sqrt(x) x>=0 diff --git a/fe/fe-core/src/main/java/org/apache/doris/catalog/BuiltinScalarFunctions.java b/fe/fe-core/src/main/java/org/apache/doris/catalog/BuiltinScalarFunctions.java index e482b419ac5613c..061929ae8525c58 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/catalog/BuiltinScalarFunctions.java +++ b/fe/fe-core/src/main/java/org/apache/doris/catalog/BuiltinScalarFunctions.java @@ -21,6 +21,7 @@ import org.apache.doris.nereids.trees.expressions.Regexp; import org.apache.doris.nereids.trees.expressions.functions.scalar.Abs; import org.apache.doris.nereids.trees.expressions.functions.scalar.Acos; +import org.apache.doris.nereids.trees.expressions.functions.scalar.Acosh; import org.apache.doris.nereids.trees.expressions.functions.scalar.AesDecrypt; import org.apache.doris.nereids.trees.expressions.functions.scalar.AesEncrypt; import org.apache.doris.nereids.trees.expressions.functions.scalar.AppendTrailingCharIfAbsent; @@ -75,9 +76,11 @@ import org.apache.doris.nereids.trees.expressions.functions.scalar.ArraysOverlap; import org.apache.doris.nereids.trees.expressions.functions.scalar.Ascii; import org.apache.doris.nereids.trees.expressions.functions.scalar.Asin; +import org.apache.doris.nereids.trees.expressions.functions.scalar.Asinh; import org.apache.doris.nereids.trees.expressions.functions.scalar.AssertTrue; import org.apache.doris.nereids.trees.expressions.functions.scalar.Atan; import org.apache.doris.nereids.trees.expressions.functions.scalar.Atan2; +import org.apache.doris.nereids.trees.expressions.functions.scalar.Atanh; import org.apache.doris.nereids.trees.expressions.functions.scalar.AutoPartitionName; import org.apache.doris.nereids.trees.expressions.functions.scalar.Bin; import org.apache.doris.nereids.trees.expressions.functions.scalar.BitCount; @@ -382,6 +385,7 @@ import org.apache.doris.nereids.trees.expressions.functions.scalar.Sha2; import org.apache.doris.nereids.trees.expressions.functions.scalar.Sign; import org.apache.doris.nereids.trees.expressions.functions.scalar.Sin; +import org.apache.doris.nereids.trees.expressions.functions.scalar.Sinh; import org.apache.doris.nereids.trees.expressions.functions.scalar.Sleep; import org.apache.doris.nereids.trees.expressions.functions.scalar.Sm3; import org.apache.doris.nereids.trees.expressions.functions.scalar.Sm3sum; @@ -498,6 +502,7 @@ public class BuiltinScalarFunctions implements FunctionHelper { public final List scalarFunctions = ImmutableList.of( scalar(Abs.class, "abs"), scalar(Acos.class, "acos"), + scalar(Acosh.class, "acosh"), scalar(AesDecrypt.class, "aes_decrypt"), scalar(AesEncrypt.class, "aes_encrypt"), scalar(AppendTrailingCharIfAbsent.class, "append_trailing_char_if_absent"), @@ -552,8 +557,10 @@ public class BuiltinScalarFunctions implements FunctionHelper { scalar(ArraysOverlap.class, "arrays_overlap"), scalar(Ascii.class, "ascii"), scalar(Asin.class, "asin"), + scalar(Asinh.class, "asinh"), scalar(AssertTrue.class, "assert_true"), scalar(Atan.class, "atan"), + scalar(Atanh.class, "atanh"), scalar(Atan2.class, "atan2"), scalar(AutoPartitionName.class, "auto_partition_name"), scalar(Bin.class, "bin"), @@ -877,6 +884,7 @@ public class BuiltinScalarFunctions implements FunctionHelper { scalar(Sha2.class, "sha2"), scalar(Sign.class, "sign"), scalar(Sin.class, "sin"), + scalar(Sinh.class, "sinh"), scalar(Sleep.class, "sleep"), scalar(StructElement.class, "struct_element"), scalar(Sm3.class, "sm3"), diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/Acosh.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/Acosh.java new file mode 100644 index 000000000000000..d7c80589524100c --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/Acosh.java @@ -0,0 +1,68 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package org.apache.doris.nereids.trees.expressions.functions.scalar; + +import org.apache.doris.catalog.FunctionSignature; +import org.apache.doris.nereids.trees.expressions.Expression; +import org.apache.doris.nereids.trees.expressions.functions.AlwaysNullable; +import org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSignature; +import org.apache.doris.nereids.trees.expressions.functions.PropagateNullLiteral; +import org.apache.doris.nereids.trees.expressions.shape.UnaryExpression; +import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor; +import org.apache.doris.nereids.types.DoubleType; + +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; + +import java.util.List; + +/** + * ScalarFunction Acosh + */ +public class Acosh extends ScalarFunction + implements UnaryExpression, ExplicitlyCastableSignature, AlwaysNullable, PropagateNullLiteral { + public static final List SIGNATURES = ImmutableList.of( + FunctionSignature.ret(DoubleType.INSTANCE).args(DoubleType.INSTANCE) + ); + + /** + * constructor with 1 argument. + */ + public Acosh(Expression arg) { + super("acosh", arg); + } + + /** + * withChildren. + */ + @Override + public Acosh withChildren(List children) { + Preconditions.checkArgument(children.size() == 1); + return new Acosh(children.get(0)); + } + + @Override + public List getSignatures() { + return SIGNATURES; + } + + @Override + public R accept(ExpressionVisitor visitor, C context) { + return visitor.visitAcosh(this, context); + } +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/Asinh.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/Asinh.java new file mode 100644 index 000000000000000..d51b2de1ae14bb1 --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/Asinh.java @@ -0,0 +1,67 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package org.apache.doris.nereids.trees.expressions.functions.scalar; + +import org.apache.doris.catalog.FunctionSignature; +import org.apache.doris.nereids.trees.expressions.Expression; +import org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSignature; +import org.apache.doris.nereids.trees.expressions.functions.PropagateNullable; +import org.apache.doris.nereids.trees.expressions.shape.UnaryExpression; +import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor; +import org.apache.doris.nereids.types.DoubleType; + +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; + +import java.util.List; + +/** + * ScalarFunction asinh + */ +public class Asinh extends ScalarFunction + implements UnaryExpression, ExplicitlyCastableSignature, PropagateNullable { + public static final List SIGNATURES = ImmutableList.of( + FunctionSignature.ret(DoubleType.INSTANCE).args(DoubleType.INSTANCE) + ); + + /** + * constructor with 1 argument. + */ + public Asinh(Expression arg) { + super("asinh", arg); + } + + /** + * withChildren. + */ + @Override + public Asinh withChildren(List children) { + Preconditions.checkArgument(children.size() == 1); + return new Asinh(children.get(0)); + } + + @Override + public List getSignatures() { + return SIGNATURES; + } + + @Override + public R accept(ExpressionVisitor visitor, C context) { + return visitor.visitAsinh(this, context); + } +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/Atanh.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/Atanh.java new file mode 100644 index 000000000000000..4f0931caf127306 --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/Atanh.java @@ -0,0 +1,68 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package org.apache.doris.nereids.trees.expressions.functions.scalar; + +import org.apache.doris.catalog.FunctionSignature; +import org.apache.doris.nereids.trees.expressions.Expression; +import org.apache.doris.nereids.trees.expressions.functions.AlwaysNullable; +import org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSignature; +import org.apache.doris.nereids.trees.expressions.functions.PropagateNullLiteral; +import org.apache.doris.nereids.trees.expressions.shape.UnaryExpression; +import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor; +import org.apache.doris.nereids.types.DoubleType; + +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; + +import java.util.List; + +/** + * ScalarFunction atanh + */ +public class Atanh extends ScalarFunction + implements UnaryExpression, ExplicitlyCastableSignature, AlwaysNullable, PropagateNullLiteral { + public static final List SIGNATURES = ImmutableList.of( + FunctionSignature.ret(DoubleType.INSTANCE).args(DoubleType.INSTANCE) + ); + + /** + * constructor with 1 argument. + */ + public Atanh(Expression arg) { + super("atanh", arg); + } + + /** + * withChildren. + */ + @Override + public Atanh withChildren(List children) { + Preconditions.checkArgument(children.size() == 1); + return new Atanh(children.get(0)); + } + + @Override + public List getSignatures() { + return SIGNATURES; + } + + @Override + public R accept(ExpressionVisitor visitor, C context) { + return visitor.visitAtanh(this, context); + } +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/Sinh.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/Sinh.java new file mode 100644 index 000000000000000..b1cdd188aa16b8d --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/Sinh.java @@ -0,0 +1,68 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package org.apache.doris.nereids.trees.expressions.functions.scalar; + +import org.apache.doris.catalog.FunctionSignature; +import org.apache.doris.nereids.trees.expressions.Expression; +import org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSignature; +import org.apache.doris.nereids.trees.expressions.functions.PropagateNullable; +import org.apache.doris.nereids.trees.expressions.shape.UnaryExpression; +import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor; +import org.apache.doris.nereids.types.DoubleType; + +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; + +import java.util.List; + +/** + * ScalarFunction Sinh + */ +public class Sinh extends ScalarFunction + implements UnaryExpression, ExplicitlyCastableSignature, PropagateNullable { + + public static final List SIGNATURES = ImmutableList.of( + FunctionSignature.ret(DoubleType.INSTANCE).args(DoubleType.INSTANCE) + ); + + /** + * constructor with 1 argument. + */ + public Sinh(Expression arg) { + super("sinh", arg); + } + + /** + * withChildren. + */ + @Override + public Sinh withChildren(List children) { + Preconditions.checkArgument(children.size() == 1); + return new Sinh(children.get(0)); + } + + @Override + public List getSignatures() { + return SIGNATURES; + } + + @Override + public R accept(ExpressionVisitor visitor, C context) { + return visitor.visitSinh(this, context); + } +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/visitor/ScalarFunctionVisitor.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/visitor/ScalarFunctionVisitor.java index 4346fb715917683..2adef5e6fed0efc 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/visitor/ScalarFunctionVisitor.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/visitor/ScalarFunctionVisitor.java @@ -23,6 +23,7 @@ import org.apache.doris.nereids.trees.expressions.functions.combinator.StateCombinator; import org.apache.doris.nereids.trees.expressions.functions.scalar.Abs; import org.apache.doris.nereids.trees.expressions.functions.scalar.Acos; +import org.apache.doris.nereids.trees.expressions.functions.scalar.Acosh; import org.apache.doris.nereids.trees.expressions.functions.scalar.AesDecrypt; import org.apache.doris.nereids.trees.expressions.functions.scalar.AesEncrypt; import org.apache.doris.nereids.trees.expressions.functions.scalar.AppendTrailingCharIfAbsent; @@ -82,9 +83,11 @@ import org.apache.doris.nereids.trees.expressions.functions.scalar.ArraysOverlap; import org.apache.doris.nereids.trees.expressions.functions.scalar.Ascii; import org.apache.doris.nereids.trees.expressions.functions.scalar.Asin; +import org.apache.doris.nereids.trees.expressions.functions.scalar.Asinh; import org.apache.doris.nereids.trees.expressions.functions.scalar.AssertTrue; import org.apache.doris.nereids.trees.expressions.functions.scalar.Atan; import org.apache.doris.nereids.trees.expressions.functions.scalar.Atan2; +import org.apache.doris.nereids.trees.expressions.functions.scalar.Atanh; import org.apache.doris.nereids.trees.expressions.functions.scalar.AutoPartitionName; import org.apache.doris.nereids.trees.expressions.functions.scalar.Bin; import org.apache.doris.nereids.trees.expressions.functions.scalar.BitCount; @@ -380,6 +383,7 @@ import org.apache.doris.nereids.trees.expressions.functions.scalar.Sha2; import org.apache.doris.nereids.trees.expressions.functions.scalar.Sign; import org.apache.doris.nereids.trees.expressions.functions.scalar.Sin; +import org.apache.doris.nereids.trees.expressions.functions.scalar.Sinh; import org.apache.doris.nereids.trees.expressions.functions.scalar.Sleep; import org.apache.doris.nereids.trees.expressions.functions.scalar.Sm3; import org.apache.doris.nereids.trees.expressions.functions.scalar.Sm3sum; @@ -496,6 +500,10 @@ default R visitAcos(Acos acos, C context) { return visitScalarFunction(acos, context); } + default R visitAcosh(Acosh acosh, C context) { + return visitScalarFunction(acosh, context); + } + default R visitAesDecrypt(AesDecrypt aesDecrypt, C context) { return visitScalarFunction(aesDecrypt, context); } @@ -732,6 +740,10 @@ default R visitAsin(Asin asin, C context) { return visitScalarFunction(asin, context); } + default R visitAsinh(Asinh asinh, C context) { + return visitScalarFunction(asinh, context); + } + default R visitAssertTrue(AssertTrue assertTrue, C context) { return visitScalarFunction(assertTrue, context); } @@ -740,6 +752,10 @@ default R visitAtan(Atan atan, C context) { return visitScalarFunction(atan, context); } + default R visitAtanh(Atanh atanh, C context) { + return visitScalarFunction(atanh, context); + } + default R visitAtan2(Atan2 atan2, C context) { return visitScalarFunction(atan2, context); } @@ -1897,6 +1913,10 @@ default R visitSin(Sin sin, C context) { return visitScalarFunction(sin, context); } + default R visitSinh(Sinh sinh, C context) { + return visitScalarFunction(sinh, context); + } + default R visitSleep(Sleep sleep, C context) { return visitScalarFunction(sleep, context); } diff --git a/regression-test/data/query_p0/sql_functions/math_functions/test_math_unary_always_nullable.out b/regression-test/data/query_p0/sql_functions/math_functions/test_math_unary_always_nullable.out index 0a190f0bd6b2f93..ae2203c03d8fb0d 100644 --- a/regression-test/data/query_p0/sql_functions/math_functions/test_math_unary_always_nullable.out +++ b/regression-test/data/query_p0/sql_functions/math_functions/test_math_unary_always_nullable.out @@ -17,6 +17,24 @@ \N true 8 \N true 9 +-- !acosh_1 -- +\N true + +-- !acosh_2 -- +\N true + +-- !acosh_3 -- +0.4435682543851154 false 0 +0.4435682543851154 false 1 +0.4435682543851154 false 2 +0.4435682543851154 false 3 +0.4435682543851154 false 4 +0.4435682543851154 false 5 +0.4435682543851154 false 6 +0.4435682543851154 false 7 +0.4435682543851154 false 8 +0.4435682543851154 false 9 + -- !asin_1 -- \N true @@ -35,6 +53,24 @@ \N true 8 \N true 9 +-- !atanh_1 -- +\N true + +-- !atanh_2 -- +\N true + +-- !atanh_3 -- +0.0 false 0 +0.0 false 1 +0.0 false 2 +0.0 false 3 +0.0 false 4 +0.0 false 5 +0.0 false 6 +0.0 false 7 +0.0 false 8 +0.0 false 9 + -- !sqrt_1 -- \N true @@ -63,6 +99,16 @@ 7 \N true 8 \N true +-- !acosh_tbl_1 -- +1 0.4435682543851154 false +2 \N true +3 \N true +4 \N true +5 \N true +6 \N true +7 \N true +8 \N true + -- !asin_tbl_1 -- 1 \N true 2 \N true @@ -73,6 +119,16 @@ 7 \N true 8 \N true +-- !atanh_tbl_1 -- +1 \N true +2 \N true +3 0.0 false +4 \N true +5 \N true +6 \N true +7 \N true +8 \N true + -- !sqrt_tbl_1 -- 1 1.0488088481701516 false 2 \N true diff --git a/regression-test/suites/query_p0/sql_functions/math_functions/test_math_unary_always_nullable.groovy b/regression-test/suites/query_p0/sql_functions/math_functions/test_math_unary_always_nullable.groovy index 282d4e3c5754e4c..64b9ddc01ef795a 100644 --- a/regression-test/suites/query_p0/sql_functions/math_functions/test_math_unary_always_nullable.groovy +++ b/regression-test/suites/query_p0/sql_functions/math_functions/test_math_unary_always_nullable.groovy @@ -30,6 +30,16 @@ suite("test_math_unary_alway_nullable") { select acos(-1.1), acos(-1.1) is NULL, number from numbers("number"="10") """ + qt_acosh_1 """ + select acosh(-1.1), acosh(-1.1) is null; + """ + qt_acosh_2 """ + select acosh(0.0), acosh(0.0) is null; + """ + qt_acosh_3 """ + select acosh(1.1), acosh(1.1) is NULL, number from numbers("number"="10") + """ + qt_asin_1 """ select asin(1.1), asin(1.1) is null; """ @@ -40,6 +50,16 @@ suite("test_math_unary_alway_nullable") { select asin(-1.1), asin(-1.1) is NULL, number from numbers("number"="10") """ + qt_atanh_1 """ + select atanh(-1.0), atanh(-1.0) is null; + """ + qt_atanh_2 """ + select atanh(1.0), atanh(1.0) is null; + """ + qt_atanh_3 """ + select atanh(0.0), atanh(0.0) is NULL, number from numbers("number"="10") + """ + qt_sqrt_1 """ select sqrt(-1), sqrt(-1) is null; """ @@ -70,10 +90,18 @@ suite("test_math_unary_alway_nullable") { select rowid, acos(val), acos(val) is null from test_math_unary_alway_nullable order by rowid; """ + qt_acosh_tbl_1 """ + select rowid, acosh(val), acosh(val) is null from test_math_unary_alway_nullable order by rowid; + """ + qt_asin_tbl_1 """ select rowid, asin(val), asin(val) is null from test_math_unary_alway_nullable order by rowid; """ + qt_atanh_tbl_1 """ + select rowid, atanh(val), atanh(val) is null from test_math_unary_alway_nullable order by rowid; + """ + qt_sqrt_tbl_1 """ select rowid, sqrt(val), sqrt(val) is null from test_math_unary_alway_nullable order by rowid; """ @@ -82,4 +110,4 @@ suite("test_math_unary_alway_nullable") { select rowid, dsqrt(val), dsqrt(val) is null from test_math_unary_alway_nullable order by rowid; """ -} \ No newline at end of file +}