You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by al...@apache.org on 2023/04/10 16:54:45 UTC
[arrow-datafusion] branch main updated: feat: hyperbolic functions (#5884)
This is an automated email from the ASF dual-hosted git repository.
alamb pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-datafusion.git
The following commit(s) were added to refs/heads/main by this push:
new bbc71692fc feat: hyperbolic functions (#5884)
bbc71692fc is described below
commit bbc71692fcd8dd9f3a9686162e59d092b37031f2
Author: Igor Izvekov <iz...@gmail.com>
AuthorDate: Mon Apr 10 19:54:39 2023 +0300
feat: hyperbolic functions (#5884)
---
datafusion/core/tests/sql/expr.rs | 6 ++
datafusion/expr/src/built_in_function.rs | 28 ++++++-
datafusion/expr/src/expr_fn.rs | 12 +++
datafusion/expr/src/function.rs | 6 ++
datafusion/physical-expr/src/functions.rs | 6 ++
datafusion/physical-expr/src/math_expressions.rs | 6 ++
datafusion/proto/proto/datafusion.proto | 6 ++
datafusion/proto/src/generated/pbjson.rs | 18 +++++
datafusion/proto/src/generated/prost.rs | 18 +++++
datafusion/proto/src/logical_plan/from_proto.rs | 22 ++++--
datafusion/proto/src/logical_plan/to_proto.rs | 6 ++
docs/source/user-guide/expressions.md | 5 +-
docs/source/user-guide/sql/scalar_functions.md | 98 ++++++++++++++++++++++--
13 files changed, 222 insertions(+), 15 deletions(-)
diff --git a/datafusion/core/tests/sql/expr.rs b/datafusion/core/tests/sql/expr.rs
index d4930d631d..672571670e 100644
--- a/datafusion/core/tests/sql/expr.rs
+++ b/datafusion/core/tests/sql/expr.rs
@@ -683,6 +683,12 @@ async fn test_mathematical_expressions_with_null() -> Result<()> {
test_expression!("asin(NULL)", "NULL");
test_expression!("acos(NULL)", "NULL");
test_expression!("atan(NULL)", "NULL");
+ test_expression!("sinh(NULL)", "NULL");
+ test_expression!("cosh(NULL)", "NULL");
+ test_expression!("tanh(NULL)", "NULL");
+ test_expression!("asinh(NULL)", "NULL");
+ test_expression!("acosh(NULL)", "NULL");
+ test_expression!("atanh(NULL)", "NULL");
test_expression!("floor(NULL)", "NULL");
test_expression!("ceil(NULL)", "NULL");
test_expression!("round(NULL)", "NULL");
diff --git a/datafusion/expr/src/built_in_function.rs b/datafusion/expr/src/built_in_function.rs
index 8280309087..becde961c6 100644
--- a/datafusion/expr/src/built_in_function.rs
+++ b/datafusion/expr/src/built_in_function.rs
@@ -36,12 +36,22 @@ pub enum BuiltinScalarFunction {
Atan,
/// atan2
Atan2,
+ /// acosh
+ Acosh,
+ /// asinh
+ Asinh,
+ /// atanh
+ Atanh,
+ /// cbrt
+ Cbrt,
/// ceil
Ceil,
/// coalesce
Coalesce,
/// cos
Cos,
+ /// cos
+ Cosh,
/// Digest
Digest,
/// exp
@@ -64,12 +74,14 @@ pub enum BuiltinScalarFunction {
Signum,
/// sin
Sin,
+ /// sinh
+ Sinh,
/// sqrt
Sqrt,
- /// cbrt
- Cbrt,
/// tan
Tan,
+ /// tanh
+ Tanh,
/// trunc
Trunc,
@@ -200,9 +212,13 @@ impl BuiltinScalarFunction {
BuiltinScalarFunction::Asin => Volatility::Immutable,
BuiltinScalarFunction::Atan => Volatility::Immutable,
BuiltinScalarFunction::Atan2 => Volatility::Immutable,
+ BuiltinScalarFunction::Acosh => Volatility::Immutable,
+ BuiltinScalarFunction::Asinh => Volatility::Immutable,
+ BuiltinScalarFunction::Atanh => Volatility::Immutable,
BuiltinScalarFunction::Ceil => Volatility::Immutable,
BuiltinScalarFunction::Coalesce => Volatility::Immutable,
BuiltinScalarFunction::Cos => Volatility::Immutable,
+ BuiltinScalarFunction::Cosh => Volatility::Immutable,
BuiltinScalarFunction::Exp => Volatility::Immutable,
BuiltinScalarFunction::Floor => Volatility::Immutable,
BuiltinScalarFunction::Ln => Volatility::Immutable,
@@ -213,9 +229,11 @@ impl BuiltinScalarFunction {
BuiltinScalarFunction::Round => Volatility::Immutable,
BuiltinScalarFunction::Signum => Volatility::Immutable,
BuiltinScalarFunction::Sin => Volatility::Immutable,
+ BuiltinScalarFunction::Sinh => Volatility::Immutable,
BuiltinScalarFunction::Sqrt => Volatility::Immutable,
BuiltinScalarFunction::Cbrt => Volatility::Immutable,
BuiltinScalarFunction::Tan => Volatility::Immutable,
+ BuiltinScalarFunction::Tanh => Volatility::Immutable,
BuiltinScalarFunction::Trunc => Volatility::Immutable,
BuiltinScalarFunction::MakeArray => Volatility::Immutable,
BuiltinScalarFunction::Ascii => Volatility::Immutable,
@@ -293,9 +311,13 @@ impl FromStr for BuiltinScalarFunction {
"acos" => BuiltinScalarFunction::Acos,
"asin" => BuiltinScalarFunction::Asin,
"atan" => BuiltinScalarFunction::Atan,
+ "acosh" => BuiltinScalarFunction::Acosh,
+ "asinh" => BuiltinScalarFunction::Asinh,
+ "atanh" => BuiltinScalarFunction::Atanh,
"atan2" => BuiltinScalarFunction::Atan2,
"ceil" => BuiltinScalarFunction::Ceil,
"cos" => BuiltinScalarFunction::Cos,
+ "cosh" => BuiltinScalarFunction::Cosh,
"exp" => BuiltinScalarFunction::Exp,
"floor" => BuiltinScalarFunction::Floor,
"ln" => BuiltinScalarFunction::Ln,
@@ -306,9 +328,11 @@ impl FromStr for BuiltinScalarFunction {
"round" => BuiltinScalarFunction::Round,
"signum" => BuiltinScalarFunction::Signum,
"sin" => BuiltinScalarFunction::Sin,
+ "sinh" => BuiltinScalarFunction::Sinh,
"sqrt" => BuiltinScalarFunction::Sqrt,
"cbrt" => BuiltinScalarFunction::Cbrt,
"tan" => BuiltinScalarFunction::Tan,
+ "tanh" => BuiltinScalarFunction::Tanh,
"trunc" => BuiltinScalarFunction::Trunc,
// conditional functions
diff --git a/datafusion/expr/src/expr_fn.rs b/datafusion/expr/src/expr_fn.rs
index 9912cecde1..521801bd95 100644
--- a/datafusion/expr/src/expr_fn.rs
+++ b/datafusion/expr/src/expr_fn.rs
@@ -450,9 +450,15 @@ scalar_expr!(Cbrt, cbrt, num, "cube root of a number");
scalar_expr!(Sin, sin, num, "sine");
scalar_expr!(Cos, cos, num, "cosine");
scalar_expr!(Tan, tan, num, "tangent");
+scalar_expr!(Sinh, sinh, num, "hyperbolic sine");
+scalar_expr!(Cosh, cosh, num, "hyperbolic cosine");
+scalar_expr!(Tanh, tanh, num, "hyperbolic tangent");
scalar_expr!(Asin, asin, num, "inverse sine");
scalar_expr!(Acos, acos, num, "inverse cosine");
scalar_expr!(Atan, atan, num, "inverse tangent");
+scalar_expr!(Asinh, asinh, num, "inverse hyperbolic sine");
+scalar_expr!(Acosh, acosh, num, "inverse hyperbolic cosine");
+scalar_expr!(Atanh, atanh, num, "inverse hyperbolic tangent");
scalar_expr!(
Floor,
floor,
@@ -763,9 +769,15 @@ mod test {
test_unary_scalar_expr!(Sin, sin);
test_unary_scalar_expr!(Cos, cos);
test_unary_scalar_expr!(Tan, tan);
+ test_unary_scalar_expr!(Sinh, sinh);
+ test_unary_scalar_expr!(Cosh, cosh);
+ test_unary_scalar_expr!(Tanh, tanh);
test_unary_scalar_expr!(Asin, asin);
test_unary_scalar_expr!(Acos, acos);
test_unary_scalar_expr!(Atan, atan);
+ test_unary_scalar_expr!(Asinh, asinh);
+ test_unary_scalar_expr!(Acosh, acosh);
+ test_unary_scalar_expr!(Atanh, atanh);
test_unary_scalar_expr!(Floor, floor);
test_unary_scalar_expr!(Ceil, ceil);
test_nary_scalar_expr!(Round, round, input);
diff --git a/datafusion/expr/src/function.rs b/datafusion/expr/src/function.rs
index 9604e4d1dc..092ecd226c 100644
--- a/datafusion/expr/src/function.rs
+++ b/datafusion/expr/src/function.rs
@@ -281,8 +281,12 @@ pub fn return_type(
| BuiltinScalarFunction::Acos
| BuiltinScalarFunction::Asin
| BuiltinScalarFunction::Atan
+ | BuiltinScalarFunction::Acosh
+ | BuiltinScalarFunction::Asinh
+ | BuiltinScalarFunction::Atanh
| BuiltinScalarFunction::Ceil
| BuiltinScalarFunction::Cos
+ | BuiltinScalarFunction::Cosh
| BuiltinScalarFunction::Exp
| BuiltinScalarFunction::Floor
| BuiltinScalarFunction::Ln
@@ -291,9 +295,11 @@ pub fn return_type(
| BuiltinScalarFunction::Round
| BuiltinScalarFunction::Signum
| BuiltinScalarFunction::Sin
+ | BuiltinScalarFunction::Sinh
| BuiltinScalarFunction::Sqrt
| BuiltinScalarFunction::Cbrt
| BuiltinScalarFunction::Tan
+ | BuiltinScalarFunction::Tanh
| BuiltinScalarFunction::Trunc => match input_expr_types[0] {
DataType::Float32 => Ok(DataType::Float32),
_ => Ok(DataType::Float64),
diff --git a/datafusion/physical-expr/src/functions.rs b/datafusion/physical-expr/src/functions.rs
index f04b192bf0..b60877f6ef 100644
--- a/datafusion/physical-expr/src/functions.rs
+++ b/datafusion/physical-expr/src/functions.rs
@@ -339,8 +339,12 @@ pub fn create_physical_fun(
BuiltinScalarFunction::Acos => Arc::new(math_expressions::acos),
BuiltinScalarFunction::Asin => Arc::new(math_expressions::asin),
BuiltinScalarFunction::Atan => Arc::new(math_expressions::atan),
+ BuiltinScalarFunction::Acosh => Arc::new(math_expressions::acosh),
+ BuiltinScalarFunction::Asinh => Arc::new(math_expressions::asinh),
+ BuiltinScalarFunction::Atanh => Arc::new(math_expressions::atanh),
BuiltinScalarFunction::Ceil => Arc::new(math_expressions::ceil),
BuiltinScalarFunction::Cos => Arc::new(math_expressions::cos),
+ BuiltinScalarFunction::Cosh => Arc::new(math_expressions::cosh),
BuiltinScalarFunction::Exp => Arc::new(math_expressions::exp),
BuiltinScalarFunction::Floor => Arc::new(math_expressions::floor),
BuiltinScalarFunction::Ln => Arc::new(math_expressions::ln),
@@ -352,9 +356,11 @@ pub fn create_physical_fun(
}
BuiltinScalarFunction::Signum => Arc::new(math_expressions::signum),
BuiltinScalarFunction::Sin => Arc::new(math_expressions::sin),
+ BuiltinScalarFunction::Sinh => Arc::new(math_expressions::sinh),
BuiltinScalarFunction::Sqrt => Arc::new(math_expressions::sqrt),
BuiltinScalarFunction::Cbrt => Arc::new(math_expressions::cbrt),
BuiltinScalarFunction::Tan => Arc::new(math_expressions::tan),
+ BuiltinScalarFunction::Tanh => Arc::new(math_expressions::tanh),
BuiltinScalarFunction::Trunc => Arc::new(math_expressions::trunc),
BuiltinScalarFunction::Power => {
Arc::new(|args| make_scalar_function(math_expressions::power)(args))
diff --git a/datafusion/physical-expr/src/math_expressions.rs b/datafusion/physical-expr/src/math_expressions.rs
index 0be352529e..7c1479c909 100644
--- a/datafusion/physical-expr/src/math_expressions.rs
+++ b/datafusion/physical-expr/src/math_expressions.rs
@@ -146,9 +146,15 @@ math_unary_function!("cbrt", cbrt);
math_unary_function!("sin", sin);
math_unary_function!("cos", cos);
math_unary_function!("tan", tan);
+math_unary_function!("sinh", sinh);
+math_unary_function!("cosh", cosh);
+math_unary_function!("tanh", tanh);
math_unary_function!("asin", asin);
math_unary_function!("acos", acos);
math_unary_function!("atan", atan);
+math_unary_function!("asinh", asinh);
+math_unary_function!("acosh", acosh);
+math_unary_function!("atanh", atanh);
math_unary_function!("floor", floor);
math_unary_function!("ceil", ceil);
math_unary_function!("trunc", trunc);
diff --git a/datafusion/proto/proto/datafusion.proto b/datafusion/proto/proto/datafusion.proto
index 4abee6d900..875a6a15cf 100644
--- a/datafusion/proto/proto/datafusion.proto
+++ b/datafusion/proto/proto/datafusion.proto
@@ -524,6 +524,12 @@ enum ScalarFunction {
CurrentTime = 71;
Uuid = 72;
Cbrt = 73;
+ Acosh = 74;
+ Asinh = 75;
+ Atanh = 76;
+ Sinh = 77;
+ Cosh = 78;
+ Tanh = 79;
}
message ScalarFunctionNode {
diff --git a/datafusion/proto/src/generated/pbjson.rs b/datafusion/proto/src/generated/pbjson.rs
index 97375681c3..63a8a2ed00 100644
--- a/datafusion/proto/src/generated/pbjson.rs
+++ b/datafusion/proto/src/generated/pbjson.rs
@@ -17084,6 +17084,12 @@ impl serde::Serialize for ScalarFunction {
Self::CurrentTime => "CurrentTime",
Self::Uuid => "Uuid",
Self::Cbrt => "Cbrt",
+ Self::Acosh => "Acosh",
+ Self::Asinh => "Asinh",
+ Self::Atanh => "Atanh",
+ Self::Sinh => "Sinh",
+ Self::Cosh => "Cosh",
+ Self::Tanh => "Tanh",
};
serializer.serialize_str(variant)
}
@@ -17169,6 +17175,12 @@ impl<'de> serde::Deserialize<'de> for ScalarFunction {
"CurrentTime",
"Uuid",
"Cbrt",
+ "Acosh",
+ "Asinh",
+ "Atanh",
+ "Sinh",
+ "Cosh",
+ "Tanh",
];
struct GeneratedVisitor;
@@ -17285,6 +17297,12 @@ impl<'de> serde::Deserialize<'de> for ScalarFunction {
"CurrentTime" => Ok(ScalarFunction::CurrentTime),
"Uuid" => Ok(ScalarFunction::Uuid),
"Cbrt" => Ok(ScalarFunction::Cbrt),
+ "Acosh" => Ok(ScalarFunction::Acosh),
+ "Asinh" => Ok(ScalarFunction::Asinh),
+ "Atanh" => Ok(ScalarFunction::Atanh),
+ "Sinh" => Ok(ScalarFunction::Sinh),
+ "Cosh" => Ok(ScalarFunction::Cosh),
+ "Tanh" => Ok(ScalarFunction::Tanh),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
diff --git a/datafusion/proto/src/generated/prost.rs b/datafusion/proto/src/generated/prost.rs
index f4f48dfe41..7764fe7848 100644
--- a/datafusion/proto/src/generated/prost.rs
+++ b/datafusion/proto/src/generated/prost.rs
@@ -2127,6 +2127,12 @@ pub enum ScalarFunction {
CurrentTime = 71,
Uuid = 72,
Cbrt = 73,
+ Acosh = 74,
+ Asinh = 75,
+ Atanh = 76,
+ Sinh = 77,
+ Cosh = 78,
+ Tanh = 79,
}
impl ScalarFunction {
/// String value of the enum field names used in the ProtoBuf definition.
@@ -2209,6 +2215,12 @@ impl ScalarFunction {
ScalarFunction::CurrentTime => "CurrentTime",
ScalarFunction::Uuid => "Uuid",
ScalarFunction::Cbrt => "Cbrt",
+ ScalarFunction::Acosh => "Acosh",
+ ScalarFunction::Asinh => "Asinh",
+ ScalarFunction::Atanh => "Atanh",
+ ScalarFunction::Sinh => "Sinh",
+ ScalarFunction::Cosh => "Cosh",
+ ScalarFunction::Tanh => "Tanh",
}
}
/// Creates an enum from field names used in the ProtoBuf definition.
@@ -2288,6 +2300,12 @@ impl ScalarFunction {
"CurrentTime" => Some(Self::CurrentTime),
"Uuid" => Some(Self::Uuid),
"Cbrt" => Some(Self::Cbrt),
+ "Acosh" => Some(Self::Acosh),
+ "Asinh" => Some(Self::Asinh),
+ "Atanh" => Some(Self::Atanh),
+ "Sinh" => Some(Self::Sinh),
+ "Cosh" => Some(Self::Cosh),
+ "Tanh" => Some(Self::Tanh),
_ => None,
}
}
diff --git a/datafusion/proto/src/logical_plan/from_proto.rs b/datafusion/proto/src/logical_plan/from_proto.rs
index 5d198d47a6..75d28ba977 100644
--- a/datafusion/proto/src/logical_plan/from_proto.rs
+++ b/datafusion/proto/src/logical_plan/from_proto.rs
@@ -33,16 +33,16 @@ use datafusion_common::{
ScalarValue,
};
use datafusion_expr::{
- abs, acos, array, ascii, asin, atan, atan2, bit_length, btrim, cbrt, ceil,
- character_length, chr, coalesce, concat_expr, concat_ws_expr, cos, date_bin,
- date_part, date_trunc, digest, exp,
+ abs, acos, acosh, array, ascii, asin, asinh, atan, atan2, atanh, bit_length, btrim,
+ cbrt, ceil, character_length, chr, coalesce, concat_expr, concat_ws_expr, cos, cosh,
+ date_bin, date_part, date_trunc, digest, exp,
expr::{self, Sort, WindowFunction},
floor, from_unixtime, left, ln, log, log10, log2,
logical_plan::{PlanType, StringifiedPlan},
lower, lpad, ltrim, md5, now, nullif, octet_length, power, random, regexp_match,
regexp_replace, repeat, replace, reverse, right, round, rpad, rtrim, sha224, sha256,
- sha384, sha512, signum, sin, split_part, sqrt, starts_with, strpos, substr,
- substring, tan, to_hex, to_timestamp_micros, to_timestamp_millis,
+ sha384, sha512, signum, sin, sinh, split_part, sqrt, starts_with, strpos, substr,
+ substring, tan, tanh, to_hex, to_timestamp_micros, to_timestamp_millis,
to_timestamp_seconds, translate, trim, trunc, upper, uuid,
window_frame::regularize,
AggregateFunction, Between, BinaryExpr, BuiltInWindowFunction, BuiltinScalarFunction,
@@ -407,6 +407,12 @@ impl From<&protobuf::ScalarFunction> for BuiltinScalarFunction {
ScalarFunction::Asin => Self::Asin,
ScalarFunction::Acos => Self::Acos,
ScalarFunction::Atan => Self::Atan,
+ ScalarFunction::Sinh => Self::Sinh,
+ ScalarFunction::Cosh => Self::Cosh,
+ ScalarFunction::Tanh => Self::Tanh,
+ ScalarFunction::Asinh => Self::Asinh,
+ ScalarFunction::Acosh => Self::Acosh,
+ ScalarFunction::Atanh => Self::Atanh,
ScalarFunction::Exp => Self::Exp,
ScalarFunction::Log => Self::Log,
ScalarFunction::Ln => Self::Ln,
@@ -1123,6 +1129,8 @@ pub fn parse_expr(
match scalar_function {
ScalarFunction::Asin => Ok(asin(parse_expr(&args[0], registry)?)),
ScalarFunction::Acos => Ok(acos(parse_expr(&args[0], registry)?)),
+ ScalarFunction::Asinh => Ok(asinh(parse_expr(&args[0], registry)?)),
+ ScalarFunction::Acosh => Ok(acosh(parse_expr(&args[0], registry)?)),
ScalarFunction::Array => Ok(array(
args.to_owned()
.iter()
@@ -1135,6 +1143,10 @@ pub fn parse_expr(
ScalarFunction::Cos => Ok(cos(parse_expr(&args[0], registry)?)),
ScalarFunction::Tan => Ok(tan(parse_expr(&args[0], registry)?)),
ScalarFunction::Atan => Ok(atan(parse_expr(&args[0], registry)?)),
+ ScalarFunction::Sinh => Ok(sinh(parse_expr(&args[0], registry)?)),
+ ScalarFunction::Cosh => Ok(cosh(parse_expr(&args[0], registry)?)),
+ ScalarFunction::Tanh => Ok(tanh(parse_expr(&args[0], registry)?)),
+ ScalarFunction::Atanh => Ok(atanh(parse_expr(&args[0], registry)?)),
ScalarFunction::Exp => Ok(exp(parse_expr(&args[0], registry)?)),
ScalarFunction::Log2 => Ok(log2(parse_expr(&args[0], registry)?)),
ScalarFunction::Ln => Ok(ln(parse_expr(&args[0], registry)?)),
diff --git a/datafusion/proto/src/logical_plan/to_proto.rs b/datafusion/proto/src/logical_plan/to_proto.rs
index c53fdf8aab..b2a30f6cd7 100644
--- a/datafusion/proto/src/logical_plan/to_proto.rs
+++ b/datafusion/proto/src/logical_plan/to_proto.rs
@@ -1255,9 +1255,15 @@ impl TryFrom<&BuiltinScalarFunction> for protobuf::ScalarFunction {
BuiltinScalarFunction::Sin => Self::Sin,
BuiltinScalarFunction::Cos => Self::Cos,
BuiltinScalarFunction::Tan => Self::Tan,
+ BuiltinScalarFunction::Sinh => Self::Sinh,
+ BuiltinScalarFunction::Cosh => Self::Cosh,
+ BuiltinScalarFunction::Tanh => Self::Tanh,
BuiltinScalarFunction::Asin => Self::Asin,
BuiltinScalarFunction::Acos => Self::Acos,
BuiltinScalarFunction::Atan => Self::Atan,
+ BuiltinScalarFunction::Asinh => Self::Asinh,
+ BuiltinScalarFunction::Acosh => Self::Acosh,
+ BuiltinScalarFunction::Atanh => Self::Atanh,
BuiltinScalarFunction::Exp => Self::Exp,
BuiltinScalarFunction::Log => Self::Log,
BuiltinScalarFunction::Ln => Self::Ln,
diff --git a/docs/source/user-guide/expressions.md b/docs/source/user-guide/expressions.md
index 85918a4518..c8eb8f2f58 100644
--- a/docs/source/user-guide/expressions.md
+++ b/docs/source/user-guide/expressions.md
@@ -69,9 +69,13 @@ expressions such as `col("a") + col("b")` to be used.
| --------------------- | ------------------------------------------------- |
| abs(x) | absolute value |
| acos(x) | inverse cosine |
+| acosh(x) | inverse hyperbolic cosine |
| asin(x) | inverse sine |
+| asinh(x) | inverse hyperbolic sine |
| atan(x) | inverse tangent |
+| atanh(x) | inverse hyperbolic tangent |
| atan2(y, x) | inverse tangent of y / x |
+| cbrt(x) | cube root |
| ceil(x) | nearest integer greater than or equal to argument |
| cos(x) | cosine |
| exp(x) | exponential |
@@ -85,7 +89,6 @@ expressions such as `col("a") + col("b")` to be used.
| signum(x) | sign of the argument (-1, 0, +1) |
| sin(x) | sine |
| sqrt(x) | square root |
-| cbrt(x) | cube root |
| tan(x) | tangent |
| trunc(x) | truncate toward zero |
diff --git a/docs/source/user-guide/sql/scalar_functions.md b/docs/source/user-guide/sql/scalar_functions.md
index ea109664c5..3fe0f4647d 100644
--- a/docs/source/user-guide/sql/scalar_functions.md
+++ b/docs/source/user-guide/sql/scalar_functions.md
@@ -23,11 +23,16 @@
- [abs](#abs)
- [acos](#acos)
+- [acosh](#acosh)
- [asin](#asin)
+- [asinh](#asinh)
- [atan](#atan)
+- [atanh](#atanh)
- [atan2](#atan2)
+- [cbrt](#cbrt)
- [ceil](#ceil)
- [cos](#cos)
+- [cosh](#cosh)
- [exp](#exp)
- [floor](#floor)
- [ln](#ln)
@@ -38,9 +43,10 @@
- [round](#round)
- [signum](#signum)
- [sin](#sin)
+- [sinh](#sinh)
- [sqrt](#sqrt)
-- [cbrt](#cbrt)
- [tan](#tan)
+- [tanh](#tanh)
- [trunc](#trunc)
### `abs`
@@ -66,6 +72,19 @@ acos(numeric_expression)
#### Arguments
+- **numeric_expression**: Numeric expression to operate on.
+ Can be a constant, column, or function, and any combination of arithmetic operators.
+
+### `acosh`
+
+Returns the area hyperbolic cosine or inverse hyperbolic cosine of a number.
+
+```
+acosh(numeric_expression)
+```
+
+#### Arguments
+
- **numeric_expression**: Numeric expression to operate on.
Can be a constant, column, or function, and any combination of arithmetic operators.
@@ -79,6 +98,19 @@ asin(numeric_expression)
#### Arguments
+- **numeric_expression**: Numeric expression to operate on.
+ Can be a constant, column, or function, and any combination of arithmetic operators.
+
+### `asinh`
+
+Returns the area hyperbolic sine or inverse hyperbolic sine of a number.
+
+```
+asinh(numeric_expression)
+```
+
+#### Arguments
+
- **numeric_expression**: Numeric expression to operate on.
Can be a constant, column, or function, and any combination of arithmetic operators.
@@ -92,6 +124,19 @@ atan(numeric_expression)
#### Arguments
+- **numeric_expression**: Numeric expression to operate on.
+ Can be a constant, column, or function, and any combination of arithmetic operators.
+
+### `atanh`
+
+Returns the area hyperbolic tangent or inverse hyperbolic tangent of a number.
+
+```
+atanh(numeric_expression)
+```
+
+#### Arguments
+
- **numeric_expression**: Numeric expression to operate on.
Can be a constant, column, or function, and any combination of arithmetic operators.
@@ -110,6 +155,19 @@ atan2(expression_y, expression_x)
- **expression_x**: Second numeric expression to operate on.
Can be a constant, column, or function, and any combination of arithmetic operators.
+### `cbrt`
+
+Returns the cube root of a number.
+
+```
+cbrt(numeric_expression)
+```
+
+#### Arguments
+
+- **numeric_expression**: Numeric expression to operate on.
+ Can be a constant, column, or function, and any combination of arithmetic operators.
+
### `ceil`
Returns the nearest integer greater than or equal to a number.
@@ -133,6 +191,19 @@ cos(numeric_expression)
#### Arguments
+- **numeric_expression**: Numeric expression to operate on.
+ Can be a constant, column, or function, and any combination of arithmetic operators.
+
+### `cosh`
+
+Returns the hyperbolic cosine of a number.
+
+```
+cosh(numeric_expression)
+```
+
+#### Arguments
+
- **numeric_expression**: Numeric expression to operate on.
Can be a constant, column, or function, and any combination of arithmetic operators.
@@ -266,12 +337,12 @@ sin(numeric_expression)
- **numeric_expression**: Numeric expression to operate on.
Can be a constant, column, or function, and any combination of arithmetic operators.
-### `sqrt`
+### `sinh`
-Returns the square root of a number.
+Returns the hyperbolic sine of a number.
```
-sqrt(numeric_expression)
+sinh(numeric_expression)
```
#### Arguments
@@ -279,12 +350,12 @@ sqrt(numeric_expression)
- **numeric_expression**: Numeric expression to operate on.
Can be a constant, column, or function, and any combination of arithmetic operators.
-### `cbrt`
+### `sqrt`
-Returns the cube root of a number.
+Returns the square root of a number.
```
-cbrt(numeric_expression)
+sqrt(numeric_expression)
```
#### Arguments
@@ -302,6 +373,19 @@ tan(numeric_expression)
#### Arguments
+- **numeric_expression**: Numeric expression to operate on.
+ Can be a constant, column, or function, and any combination of arithmetic operators.
+
+### `tanh`
+
+Returns the hyperbolic tangent of a number.
+
+```
+tanh(numeric_expression)
+```
+
+#### Arguments
+
- **numeric_expression**: Numeric expression to operate on.
Can be a constant, column, or function, and any combination of arithmetic operators.