Added postgres erfc

.github/workflows/rust.yml

@@ -113,4 +113,4 @@ jobs:
     - name: Build
       run: cargo build --verbose
     - name: Run tests
-      run: cargo test --features "postgres" --verbose
+      run: cargo test --all-features --verbose

src/postgres/math_udfs.rs

@@ -88,6 +88,57 @@ pub fn erf(args: &[ArrayRef]) -> Result<ArrayRef> {
     Ok(Arc::new(float64array_builder.finish()) as ArrayRef)
 }
 
+/// Complementary error function
+pub fn erfc(args: &[ArrayRef]) -> Result<ArrayRef> {
+    let column_data = &args[0];
+    let data = column_data.into_data();
+    let data_type = data.data_type();
+
+    let mut float64array_builder = Float64Array::builder(args[0].len());
+    match data_type {
+        DataType::Float64 => {
+            let values = datafusion::common::cast::as_float64_array(&args[0])?;
+            values.iter().try_for_each(|value| {
+                if let Some(value) = value {
+                    float64array_builder.append_value(libm::erfc(value))
+                } else {
+                    float64array_builder.append_null();
+                }
+                Ok::<(), DataFusionError>(())
+            })?;
+        }
+        DataType::Int64 => {
+            let values = datafusion::common::cast::as_int64_array(&args[0])?;
+            values.iter().try_for_each(|value| {
+                if let Some(value) = value {
+                    float64array_builder.append_value(libm::erfc(value as f64))
+                } else {
+                    float64array_builder.append_null();
+                }
+                Ok::<(), DataFusionError>(())
+            })?;
+        }
+        DataType::UInt64 => {
+            let values = datafusion::common::cast::as_uint64_array(&args[0])?;
+            values.iter().try_for_each(|value| {
+                if let Some(value) = value {
+                    float64array_builder.append_value(libm::erfc(value as f64))
+                } else {
+                    float64array_builder.append_null();
+                }
+                Ok::<(), DataFusionError>(())
+            })?;
+        }
+        t => {
+            return Err(DataFusionError::Internal(format!(
+                "Unsupported type {t} for erf function"
+            )))
+        }
+    };
+
+    Ok(Arc::new(float64array_builder.finish()) as ArrayRef)
+}
+
 #[cfg(feature = "postgres")]
 #[cfg(test)]
 mod tests {
@@ -178,6 +229,37 @@ mod tests {
         Ok(())
     }
 
+    #[tokio::test]
+    async fn test_erfc() -> Result<()> {
+        let ctx = register_udfs_for_test()?;
+        let df = ctx.sql("select index, uint as uint, int as int, float as float from maths_table ORDER BY index ASC").await?;
+        df.show().await?;
+
+        let df = ctx.sql("select index, erfc(uint) as uint, erfc(int) as int, erfc(float) as float from maths_table ORDER BY index ASC").await?;
+
+        let batches = df.clone().collect().await?;
+
+        let expected: Vec<&str> = r#"
++-------+-------------------------+-------------------------+----------------------+
+| index | uint                    | int                     | float                |
++-------+-------------------------+-------------------------+----------------------+
+| 1     | 0.004677734981047266    | 1.9953222650189528      | 0.15729920705028513  |
+| 2     | 0.000022090496998585438 | 0.000022090496998585438 | 3.057709796438165e-6 |
+| 3     |                         |                         |                      |
++-------+-------------------------+-------------------------+----------------------+"#
+            .split('\n')
+            .filter_map(|input| {
+                if input.is_empty() {
+                    None
+                } else {
+                    Some(input.trim())
+                }
+            })
+            .collect();
+        assert_batches_sorted_eq!(expected, &batches);
+        Ok(())
+    }
+
     fn register_udfs_for_test() -> Result<SessionContext> {
         let ctx = set_up_maths_data_test()?;
         register_postgres_udfs(&ctx)?;

src/postgres/mod.rs

@@ -2,7 +2,7 @@
 
 use std::sync::Arc;
 
-use crate::postgres::math_udfs::{ceiling, div, erf};
+use crate::postgres::math_udfs::{ceiling, div, erf, erfc};
 use crate::postgres::network_udfs::{
     broadcast, family, host, hostmask, inet_merge, inet_same_family, masklen, netmask, network,
     set_masklen,
@@ -25,6 +25,7 @@ pub fn register_postgres_udfs(ctx: &SessionContext) -> Result<()> {
 fn register_math_udfs(ctx: &SessionContext) -> Result<()> {
     register_ceiling(ctx);
     register_erf(ctx);
+    register_erfc(ctx);
     register_div(ctx);
     Ok(())
 }
@@ -55,6 +56,19 @@ fn register_erf(ctx: &SessionContext) {
     ctx.register_udf(erf_udf);
 }
 
+fn register_erfc(ctx: &SessionContext) {
+    let erfc_udf = make_scalar_function(erfc);
+    let return_type: ReturnTypeFunction = Arc::new(move |_| Ok(Arc::new(Float64)));
+    let erfc_udf = ScalarUDF::new(
+        "erfc",
+        &Signature::uniform(1, vec![Int64, UInt64, Float64], Volatility::Immutable),
+        &return_type,
+        &erfc_udf,
+    );
+
+    ctx.register_udf(erfc_udf);
+}
+
 fn register_div(ctx: &SessionContext) {
     let udf = make_scalar_function(div);
     let return_type: ReturnTypeFunction = Arc::new(move |_| Ok(Arc::new(Int64)));

supports/postgres.md

@@ -26,7 +26,7 @@ https://www.postgresql.org/docs/16/functions-math.html
 | ✅︎          | ceiling ( numeric ) → numeric                                                              | Nearest integer greater than or equal to argument (same as ceil)                                                                                                                              | ceiling(95.3) → 96                      |
 | ✅︎          | div ( y numeric, x numeric ) → numeric                                                     | Integer quotient of y/x (truncates towards zero)                                                                                                                                              | div(9, 4) → 2                           | 
 | ✅︎          | erf ( double precision ) → double precision                                                | Error function                                                                                                                                                                                | erf(1.0) → 0.8427007929497149           |
-| ❓           | erfc ( double precision ) → double precision                                               | Complementary error function (1 - erf(x), without loss of precision for large inputs)                                                                                                         | erfc(1.0) → 0.15729920705028513         | 
+| ✅           | erfc ( double precision ) → double precision                                               | Complementary error function (1 - erf(x), without loss of precision for large inputs)                                                                                                         | erfc(1.0) → 0.15729920705028513         | 
 | ❓           | min_scale ( numeric ) → integer                                                            | Minimum scale (number of fractional decimal digits) needed to represent the supplied value precisely                                                                                          | min_scale(8.4100) → 2                   | 
 | ❓           | mod ( y numeric_type, x numeric_type ) → numeric_type                                      | Remainder of y/x; available for smallint, integer, bigint, and numeric                                                                                                                        | mod(9, 4) → 1                           | 
 | ❓           | scale ( numeric ) → integer                                                                | Scale of the argument (the number of decimal digits in the fractional part)                                                                                                                   | scale(8.4100) → 4                       |