Added postgres sind

src/postgres/math_udfs.rs

@@ -88,6 +88,25 @@ pub fn asind(args: &[ArrayRef]) -> Result<ArrayRef> {
  Ok(Arc::new(float64array_builder.finish()) as ArrayRef)
 }
 
+/// Sine, argument in degrees.
+pub fn sind(args: &[ArrayRef]) -> Result<ArrayRef> {
+ let values = datafusion::common::cast::as_float64_array(&args[0])?;
+ let mut float64array_builder = Float64Array::builder(args[0].len());
+
+ values.iter().try_for_each(|value| {
+ if let Some(value) = value {
+ let result = value.to_radians().sin();
+ float64array_builder.append_value(result);
+ Ok::<(), DataFusionError>(())
+ } else {
+ float64array_builder.append_null();
+ Ok::<(), DataFusionError>(())
+ }
+ })?;
+
+ Ok(Arc::new(float64array_builder.finish()) as ArrayRef)
+}
+
 /// Nearest integer greater than or equal to argument (same as ceil).
 pub fn ceiling(args: &[ArrayRef]) -> Result<ArrayRef> {
  let values = datafusion::common::cast::as_float64_array(&args[0])?;
@@ -338,7 +357,7 @@ mod tests {
  }
 
  #[tokio::test]
- async fn test_sind() -> Result<()> {
+ async fn test_asind() -> Result<()> {
  let ctx = register_udfs_for_test()?;
  let df = ctx.sql("select asind(0.5) as col_result").await?;
 
@@ -385,6 +404,54 @@ mod tests {
  Ok(())
  }
 
+ #[tokio::test]
+ async fn test_sind() -> Result<()> {
+ let ctx = register_udfs_for_test()?;
+ let df = ctx.sql("select sind(30) as col_result").await?;
+
+ let batches = df.clone().collect().await?;
+
+ let expected: Vec<&str> = r#"
++---------------------+
+| col_result |
++---------------------+
+| 0.49999999999999994 |
++---------------------+"#
+ .split('\n')
+ .filter_map(|input| {
+ if input.is_empty() {
+ None
+ } else {
+ Some(input.trim())
+ }
+ })
+ .collect();
+ assert_batches_sorted_eq!(expected, &batches);
+
+ let df = ctx.sql("select sind(0.4) as col_result").await?;
+
+ let batches = df.clone().collect().await?;
+
+ let expected: Vec<&str> = r#"
++-----------------------+
+| col_result |
++-----------------------+
+| 0.0069812602979615525 |
++-----------------------+"#
+ .split('\n')
+ .filter_map(|input| {
+ if input.is_empty() {
+ None
+ } else {
+ Some(input.trim())
+ }
+ })
+ .collect();
+ assert_batches_sorted_eq!(expected, &batches);
+
+ Ok(())
+ }
+
  #[tokio::test]
  async fn test_ceiling() -> Result<()> {
  let ctx = register_udfs_for_test()?;

src/postgres/mod.rs

@@ -2,7 +2,7 @@
 
 use std::sync::Arc;
 
-use crate::postgres::math_udfs::{acosd, asind, ceiling, cosd, div, erf, erfc};
+use crate::postgres::math_udfs::{acosd, asind, ceiling, cosd, div, erf, erfc, sind};
 use crate::postgres::network_udfs::{
  broadcast, family, host, hostmask, inet_merge, inet_same_family, masklen, netmask, network,
  set_masklen,
@@ -24,8 +24,9 @@ pub fn register_postgres_udfs(ctx: &SessionContext) -> Result<()> {
 
 fn register_math_udfs(ctx: &SessionContext) -> Result<()> {
  register_acosd(ctx);
- register_asind(ctx);
  register_cosd(ctx);
+ register_asind(ctx);
+ register_sind(ctx);
  register_ceiling(ctx);
  register_erf(ctx);
  register_erfc(ctx);
@@ -59,6 +60,19 @@ fn register_asind(ctx: &SessionContext) {
  ctx.register_udf(asind_udf);
 }
 
+fn register_sind(ctx: &SessionContext) {
+ let sind_udf = make_scalar_function(sind);
+ let return_type: ReturnTypeFunction = Arc::new(move |_| Ok(Arc::new(Float64)));
+ let sind_udf = ScalarUDF::new(
+ "sind",
+ &Signature::uniform(1, vec![Float64], Volatility::Immutable),
+ &return_type,
+ &sind_udf,
+ );
+
+ ctx.register_udf(sind_udf);
+}
+
 fn register_cosd(ctx: &SessionContext) {
  let cosd_udf = make_scalar_function(cosd);
  let return_type: ReturnTypeFunction = Arc::new(move |_| Ok(Arc::new(Float64)));

supports/postgres.md

@@ -39,5 +39,5 @@ https://www.postgresql.org/docs/16/functions-math.html
 | ❓ | atand ( double precision ) → double precision | Inverse tangent, result in degrees | atand(1) → 45 | 
 | ✅ | cosd ( double precision ) → double precision | Cosine, argument in degrees | cosd(60) → 0.5 | 
 | ❓ | cotd ( double precision ) → double precision | Cotangent, argument in degrees | cotd(45) → 1 | 
-| ❓ | sind ( double precision ) → double precision | Sine, argument in degrees | sind(30) → 0.5 | 
+| ✅ | sind ( double precision ) → double precision | Sine, argument in degrees | sind(30) → 0.5 | 
 | ❓ | tand ( double precision ) → double precision | Tangent, argument in degrees | tand(45) → 1 |