feat(expr): Various trigonometric functions

proto/expr.proto

@@ -104,6 +104,14 @@ message ExprNode {
  STRPOS = 241;
  TO_ASCII = 242;
  TO_HEX = 243;
+ SIN = 245;
+ COS = 246;
+ TAN = 247; 
+ COT = 248; 
+ ASIN = 249; 
+ ACOS = 250; 
+ ATAN = 251; 
+ ATAN2 = 252; 
 
  // Boolean comparison
  IS_TRUE = 301;

src/common/Cargo.toml

@@ -58,7 +58,7 @@ rand = "0.8"
 regex = "1"
 reqwest = { version = "0.11", features = ["json"] }
 risingwave_pb = { path = "../prost" }
-rust_decimal = { version = "1", features = ["db-tokio-postgres"] }
+rust_decimal = { version = "1", features = ["db-tokio-postgres", "maths"] }
 ryu = "1.0"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

src/common/src/types/decimal.rs

@@ -19,6 +19,7 @@ use std::ops::{Add, Div, Mul, Neg, Rem, Sub};
 use bytes::{BufMut, Bytes, BytesMut};
 use num_traits::{CheckedAdd, CheckedDiv, CheckedMul, CheckedNeg, CheckedRem, CheckedSub, Zero};
 use postgres_types::{ToSql, Type};
+use rust_decimal::prelude::MathematicalOps;
 pub use rust_decimal::prelude::{FromPrimitive, FromStr, ToPrimitive};
 use rust_decimal::{Decimal as RustDecimal, Error, RoundingStrategy};
 
@@ -499,6 +500,71 @@ impl Decimal {
  }
  }
 
+ #[must_use]
+ pub fn sin(&self) -> Self {
+ match self {
+ Self::Normalized(d) => Self::Normalized(d.sin()),
+ d => *d,
+ }
+ }
+
+ #[must_use]
+ pub fn cos(&self) -> Self {
+ match self {
+ Self::Normalized(d) => Self::Normalized(d.cos()),
+ d => *d,
+ }
+ }
+
+ #[must_use]
+ pub fn tan(&self) -> Self {
+ match self {
+ Self::Normalized(d) => Self::Normalized(d.tan()),
+ d => *d,
+ }
+ }
+
+ #[must_use]
+ pub fn cot(&self) -> Self {
+ match self {
+ Self::Normalized(d) => Self::Normalized(d.cos() / d.sin()),
+ d => *d,
+ }
+ }
+
+ #[must_use]
+ pub fn asin(&self) -> Self {
+ match self {
+ Self::Normalized(d) => Self::Normalized(*d).to_f64().expect("Expected valid f64 value").asin().into(),
+ d => d.to_f64().expect("Expected valid f64 value").asin().into(),
+ }
+ }
+
+ #[must_use]
+ pub fn acos(&self) -> Self {
+ match self {
+ Self::Normalized(d) => Self::Normalized(*d).to_f64().expect("Expected valid f64 value").acos().into(),
+ d => d.to_f64().expect("Expected valid f64 value").acos().into(),
+ }
+ }
+
+ #[must_use]
+ pub fn atan(&self) -> Self {
+ match self {
+ Self::Normalized(d) => Self::Normalized(*d).to_f64().expect("Expected valid f64 value").atan().into(),
+ d => d.to_f64().expect("Expected valid f64 value").atan().into(),
+ }
+ }
+
+ #[must_use]
+ pub fn atan2(&self) -> Self {
+ match self {
+ // Somehow pass 2 args here. Do not just pass 0
+ Self::Normalized(d) => Self::Normalized(*d).to_f64().expect("Expected valid f64 value").atan2(0 as f64).into(),
+ d => d.to_f64().expect("Expected valid f64 value").atan2(0 as f64).into(),
+ }
+ }
+
  #[must_use]
  pub fn floor(&self) -> Self {
  match self {

src/expr/src/vector_op/round.rs

@@ -26,6 +26,90 @@ pub fn round_digits<D: Into<i32>>(input: Decimal, digits: D) -> Decimal {
  }
 }
 
+// TODO: add sin here?
+
+#[function("sin(float64) -> float64")]
+pub fn sin_f64(input: F64) -> F64 {
+ f64::sin(input.0).into()
+}
+
+#[function("sin(decimal) -> decimal")]
+pub fn sin_decimal(input: Decimal) -> Decimal {
+ input.sin()
+}
+
+#[function("cos(float64) -> float64")]
+pub fn cos_f64(input: F64) -> F64 {
+ f64::cos(input.0).into()
+}
+
+#[function("cos(decimal) -> decimal")]
+pub fn cos_decimal(input: Decimal) -> Decimal {
+ input.cos()
+}
+
+#[function("tan(float64) -> float64")]
+pub fn tan_f64(input: F64) -> F64 {
+ f64::tan(input.0).into()
+}
+
+#[function("tan(decimal) -> decimal")]
+pub fn tan_decimal(input: Decimal) -> Decimal {
+ input.tan()
+}
+
+#[function("cot(float64) -> float64")]
+pub fn cot_f64(input: F64) -> F64 {
+ f64::cot(input.0).into() // TODO
+}
+
+#[function("cot(decimal) -> decimal")]
+pub fn cot_decimal(input: Decimal) -> Decimal {
+ input.cot()
+}
+
+#[function("asin(float64) -> float64")]
+pub fn asin_f64(input: F64) -> F64 {
+ f64::asin(input.0).into()
+}
+
+#[function("asin(decimal) -> decimal")]
+pub fn asin_decimal(input: Decimal) -> Decimal {
+ input.asin()
+}
+
+#[function("acos(float64) -> float64")]
+pub fn acos_f64(input: F64) -> F64 {
+ f64::acos(input.0).into()
+}
+
+#[function("acos(decimal) -> decimal")]
+pub fn acos_decimal(input: Decimal) -> Decimal {
+ input.acos()
+}
+
+#[function("atan(float64) -> float64")]
+pub fn atan_f64(input: F64) -> F64 {
+ f64::atan(input.0).into()
+}
+
+#[function("atan(decimal) -> decimal")]
+pub fn atan_decimal(input: Decimal) -> Decimal {
+ input.atan()
+}
+// TODO: how do I pass 2 args here?
+#[function("atan2(float64, float64) -> float64")]
+pub fn atan2_f64(input: F64) -> F64 {
+ f64::atan2(input.0, input.1).into()
+}
+
+
+#[function("atan2(decimal) -> decimal")]
+pub fn atan2_decimal(input: Decimal) -> Decimal {
+ input.atan2()
+}
+
+
 #[function("ceil(float64) -> float64")]
 pub fn ceil_f64(input: F64) -> F64 {
  f64::ceil(input.0).into()

src/frontend/src/binder/expr/function.rs

@@ -346,6 +346,16 @@ impl Binder {
  ("abs", raw_call(ExprType::Abs)),
  ("exp", raw_call(ExprType::Exp)),
  ("mod", raw_call(ExprType::Modulus)),
+ ("sin", raw_call(ExprType::Sin)),
+ ("cos", raw_call(ExprType::Cos)), 
+ ("tan", raw_call(ExprType::Tan)), 
+ ("cot", raw_call(ExprType::Cot)), 
+ ("asin", raw_call(ExprType::Asin)), 
+ ("acos", raw_call(ExprType::Acos)), 
+ ("atan", raw_call(ExprType::Atan)), 
+ ("atan2", raw_call(ExprType::Atan2)), 
+
+ // TODO: add here
  (
  "to_timestamp",
  dispatch_by_len(vec![