Move ascii function to datafusion_functions

datafusion/expr/src/built_in_function.rs

@@ -103,8 +103,6 @@ pub enum BuiltinScalarFunction {
     Cot,
 
     // string functions
-    /// ascii
-    Ascii,
     /// bit_length
     BitLength,
     /// btrim
@@ -246,7 +244,6 @@ impl BuiltinScalarFunction {
             BuiltinScalarFunction::Cbrt => Volatility::Immutable,
             BuiltinScalarFunction::Cot => Volatility::Immutable,
             BuiltinScalarFunction::Trunc => Volatility::Immutable,
-            BuiltinScalarFunction::Ascii => Volatility::Immutable,
             BuiltinScalarFunction::BitLength => Volatility::Immutable,
             BuiltinScalarFunction::Btrim => Volatility::Immutable,
             BuiltinScalarFunction::CharacterLength => Volatility::Immutable,
@@ -299,7 +296,6 @@ impl BuiltinScalarFunction {
         // the return type of the built in function.
         // Some built-in functions' return type depends on the incoming type.
         match self {
-            BuiltinScalarFunction::Ascii => Ok(Int32),
             BuiltinScalarFunction::BitLength => {
                 utf8_to_int_type(&input_expr_types[0], "bit_length")
             }
@@ -447,8 +443,7 @@ impl BuiltinScalarFunction {
             BuiltinScalarFunction::Coalesce => {
                 Signature::variadic_equal(self.volatility())
             }
-            BuiltinScalarFunction::Ascii
-            | BuiltinScalarFunction::BitLength
+            BuiltinScalarFunction::BitLength
             | BuiltinScalarFunction::CharacterLength
             | BuiltinScalarFunction::InitCap
             | BuiltinScalarFunction::Lower
@@ -701,7 +696,6 @@ impl BuiltinScalarFunction {
             BuiltinScalarFunction::Coalesce => &["coalesce"],
 
             // string functions
-            BuiltinScalarFunction::Ascii => &["ascii"],
             BuiltinScalarFunction::BitLength => &["bit_length"],
             BuiltinScalarFunction::Btrim => &["btrim"],
             BuiltinScalarFunction::CharacterLength => {

datafusion/expr/src/expr_fn.rs

@@ -579,7 +579,6 @@ scalar_expr!(Uuid, uuid, , "returns uuid v4 as a string value");
 scalar_expr!(Log, log, base x, "logarithm of a `x` for a particular `base`");
 
 // string functions
-scalar_expr!(Ascii, ascii, chr, "ASCII code value of the character");
 scalar_expr!(
     BitLength,
     bit_length,
@@ -1080,7 +1079,6 @@ mod test {
         test_scalar_expr!(Nanvl, nanvl, x, y);
         test_scalar_expr!(Iszero, iszero, input);
 
-        test_scalar_expr!(Ascii, ascii, input);
         test_scalar_expr!(BitLength, bit_length, string);
         test_nary_scalar_expr!(Btrim, btrim, string);
         test_nary_scalar_expr!(Btrim, btrim, string, characters);

datafusion/functions/src/string/ascii.rs

@@ -0,0 +1,92 @@
+// 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.
+
+use arrow::array::Int32Array;
+use arrow::array::{ArrayRef, OffsetSizeTrait};
+use arrow::datatypes::DataType;
+use datafusion_common::{cast::as_generic_string_array, internal_err, Result};
+use datafusion_expr::ColumnarValue;
+use datafusion_expr::{ScalarUDFImpl, Signature, Volatility};
+use std::any::Any;
+use std::sync::Arc;
+
+use crate::string::make_scalar_function;
+
+/// Returns the numeric code of the first character of the argument.
+/// ascii('x') = 120
+pub fn ascii<T: OffsetSizeTrait>(args: &[ArrayRef]) -> Result<ArrayRef> {
+    let string_array = as_generic_string_array::<T>(&args[0])?;
+
+    let result = string_array
+        .iter()
+        .map(|string| {
+            string.map(|string: &str| {
+                let mut chars = string.chars();
+                chars.next().map_or(0, |v| v as i32)
+            })
+        })
+        .collect::<Int32Array>();
+
+    Ok(Arc::new(result) as ArrayRef)
+}
+
+#[derive(Debug)]
+pub(super) struct AsciiFunc {
+    signature: Signature,
+}
+impl AsciiFunc {
+    pub fn new() -> Self {
+        use DataType::*;
+        Self {
+            signature: Signature::uniform(
+                1,
+                vec![Utf8, LargeUtf8],
+                Volatility::Immutable,
+            ),
+        }
+    }
+}
+
+impl ScalarUDFImpl for AsciiFunc {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn name(&self) -> &str {
+        "ascii"
+    }
+
+    fn signature(&self) -> &Signature {
+        &self.signature
+    }
+
+    fn return_type(&self, _arg_types: &[DataType]) -> Result<DataType> {
+        use DataType::*;
+
+        Ok(Int32)
+    }
+
+    fn invoke(&self, args: &[ColumnarValue]) -> Result<ColumnarValue> {
+        match args[0].data_type() {
+            DataType::Utf8 => make_scalar_function(ascii::<i32>, vec![])(args),
+            DataType::LargeUtf8 => {
+                return make_scalar_function(ascii::<i64>, vec![])(args);
+            }
+            _ => internal_err!("Unsupported data type"),
+        }
+    }
+}

datafusion/functions/src/string/mod.rs

@@ -265,17 +265,23 @@ where
     })
 }
 
+mod ascii;
 mod starts_with;
 mod to_hex;
 mod trim;
 mod upper;
 // create UDFs
+make_udf_function!(ascii::AsciiFunc, ASCII, ascii);
 make_udf_function!(starts_with::StartsWithFunc, STARTS_WITH, starts_with);
 make_udf_function!(to_hex::ToHexFunc, TO_HEX, to_hex);
 make_udf_function!(trim::TrimFunc, TRIM, trim);
 make_udf_function!(upper::UpperFunc, UPPER, upper);
 
 export_functions!(
+    (
+        ascii,
+        arg1,
+        "Returns the numeric code of the first character of the argument."),
     (
     starts_with,
     arg1 arg2,

datafusion/physical-expr/src/functions.rs

@@ -252,15 +252,6 @@ pub fn create_physical_fun(
             Arc::new(|args| make_scalar_function_inner(math_expressions::cot)(args))
         }
         // string functions
-        BuiltinScalarFunction::Ascii => Arc::new(|args| match args[0].data_type() {
-            DataType::Utf8 => {
-                make_scalar_function_inner(string_expressions::ascii::<i32>)(args)
-            }
-            DataType::LargeUtf8 => {
-                make_scalar_function_inner(string_expressions::ascii::<i64>)(args)
-            }
-            other => exec_err!("Unsupported data type {other:?} for function ascii"),
-        }),
         BuiltinScalarFunction::BitLength => Arc::new(|args| match &args[0] {
             ColumnarValue::Array(v) => Ok(ColumnarValue::Array(bit_length(v.as_ref())?)),
             ColumnarValue::Scalar(v) => match v {
@@ -708,33 +699,6 @@ mod tests {
 
     #[test]
     fn test_functions() -> Result<()> {
-        test_function!(Ascii, &[lit("x")], Ok(Some(120)), i32, Int32, Int32Array);
-        test_function!(Ascii, &[lit("ésoj")], Ok(Some(233)), i32, Int32, Int32Array);
-        test_function!(
-            Ascii,
-            &[lit("💯")],
-            Ok(Some(128175)),
-            i32,
-            Int32,
-            Int32Array
-        );
-        test_function!(
-            Ascii,
-            &[lit("💯a")],
-            Ok(Some(128175)),
-            i32,
-            Int32,
-            Int32Array
-        );
-        test_function!(Ascii, &[lit("")], Ok(Some(0)), i32, Int32, Int32Array);
-        test_function!(
-            Ascii,
-            &[lit(ScalarValue::Utf8(None))],
-            Ok(None),
-            i32,
-            Int32,
-            Int32Array
-        );
         test_function!(
             BitLength,
             &[lit("chars")],

datafusion/physical-expr/src/string_expressions.rs

@@ -118,24 +118,6 @@ where
     }
 }
 
-/// Returns the numeric code of the first character of the argument.
-/// ascii('x') = 120
-pub fn ascii<T: OffsetSizeTrait>(args: &[ArrayRef]) -> Result<ArrayRef> {
-    let string_array = as_generic_string_array::<T>(&args[0])?;
-
-    let result = string_array
-        .iter()
-        .map(|string| {
-            string.map(|string: &str| {
-                let mut chars = string.chars();
-                chars.next().map_or(0, |v| v as i32)
-            })
-        })
-        .collect::<Int32Array>();
-
-    Ok(Arc::new(result) as ArrayRef)
-}
-
 /// Returns the character with the given code. chr(0) is disallowed because text data types cannot store that character.
 /// chr(65) = 'A'
 pub fn chr(args: &[ArrayRef]) -> Result<ArrayRef> {

datafusion/proto/proto/datafusion.proto

@@ -545,7 +545,7 @@ enum ScalarFunction {
   //  1 was Acos
   //  2 was Asin
   Atan = 3;
-  Ascii = 4;
+  // 4 was Ascii
   Ceil = 5;
   Cos = 6;
   // 7 was Digest

datafusion/proto/src/logical_plan/from_proto.rs

@@ -48,9 +48,8 @@ use datafusion_expr::expr::Unnest;
 use datafusion_expr::expr::{Alias, Placeholder};
 use datafusion_expr::window_frame::{check_window_frame, regularize_window_order_by};
 use datafusion_expr::{
-    acosh, ascii, asinh, atan, atan2, atanh, bit_length, btrim, cbrt, ceil,
-    character_length, chr, coalesce, concat_expr, concat_ws_expr, cos, cosh, cot,
-    degrees, ends_with, exp,
+    acosh, asinh, atan, atan2, atanh, bit_length, btrim, cbrt, ceil, character_length,
+    chr, coalesce, concat_expr, concat_ws_expr, cos, cosh, cot, degrees, ends_with, exp,
     expr::{self, InList, Sort, WindowFunction},
     factorial, find_in_set, floor, gcd, initcap, iszero, lcm, left, levenshtein, ln, log,
     log10, log2,
@@ -465,7 +464,6 @@ impl From<&protobuf::ScalarFunction> for BuiltinScalarFunction {
             ScalarFunction::Rtrim => Self::Rtrim,
             ScalarFunction::Log2 => Self::Log2,
             ScalarFunction::Signum => Self::Signum,
-            ScalarFunction::Ascii => Self::Ascii,
             ScalarFunction::BitLength => Self::BitLength,
             ScalarFunction::Btrim => Self::Btrim,
             ScalarFunction::CharacterLength => Self::CharacterLength,
@@ -1445,9 +1443,6 @@ pub fn parse_expr(
                 ScalarFunction::Rtrim => {
                     Ok(rtrim(parse_expr(&args[0], registry, codec)?))
                 }
-                ScalarFunction::Ascii => {
-                    Ok(ascii(parse_expr(&args[0], registry, codec)?))
-                }
                 ScalarFunction::BitLength => {
                     Ok(bit_length(parse_expr(&args[0], registry, codec)?))
                 }

datafusion/proto/src/logical_plan/to_proto.rs

@@ -1485,7 +1485,6 @@ impl TryFrom<&BuiltinScalarFunction> for protobuf::ScalarFunction {
             BuiltinScalarFunction::Rtrim => Self::Rtrim,
             BuiltinScalarFunction::Log2 => Self::Log2,
             BuiltinScalarFunction::Signum => Self::Signum,
-            BuiltinScalarFunction::Ascii => Self::Ascii,
             BuiltinScalarFunction::BitLength => Self::BitLength,
             BuiltinScalarFunction::Btrim => Self::Btrim,
             BuiltinScalarFunction::CharacterLength => Self::CharacterLength,

datafusion/sqllogictest/test_files/expr.slt

@@ -335,6 +335,21 @@ SELECT ascii(NULL)
 ----
 NULL
 
+query I
+SELECT ascii('ésoj')
+----
+233
+
+query I
+SELECT ascii('💯')
+----
+128175
+
+query I
+SELECT ascii('💯a')
+----
+128175
+
 query I
 SELECT bit_length('')
 ----