1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

// 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.

//! "unicode" DataFusion functions

use std::sync::Arc;

use datafusion_expr::ScalarUDF;

pub mod character_length;
pub mod find_in_set;
pub mod left;
pub mod lpad;
pub mod reverse;
pub mod right;
pub mod rpad;
pub mod strpos;
pub mod substr;
pub mod substrindex;
pub mod translate;

// create UDFs
make_udf_function!(
    character_length::CharacterLengthFunc,
    CHARACTER_LENGTH,
    character_length
);
make_udf_function!(find_in_set::FindInSetFunc, FIND_IN_SET, find_in_set);
make_udf_function!(left::LeftFunc, LEFT, left);
make_udf_function!(lpad::LPadFunc, LPAD, lpad);
make_udf_function!(right::RightFunc, RIGHT, right);
make_udf_function!(reverse::ReverseFunc, REVERSE, reverse);
make_udf_function!(rpad::RPadFunc, RPAD, rpad);
make_udf_function!(strpos::StrposFunc, STRPOS, strpos);
make_udf_function!(substr::SubstrFunc, SUBSTR, substr);
make_udf_function!(substrindex::SubstrIndexFunc, SUBSTR_INDEX, substr_index);
make_udf_function!(translate::TranslateFunc, TRANSLATE, translate);

pub mod expr_fn {
    use datafusion_expr::Expr;

    #[doc = "the number of characters in the `string`"]
    pub fn char_length(string: Expr) -> Expr {
        character_length(string)
    }

    #[doc = "the number of characters in the `string`"]
    pub fn character_length(string: Expr) -> Expr {
        super::character_length().call(vec![string])
    }

    #[doc = "Returns a value in the range of 1 to N if the string str is in the string list strlist consisting of N substrings"]
    pub fn find_in_set(string: Expr, strlist: Expr) -> Expr {
        super::find_in_set().call(vec![string, strlist])
    }

    #[doc = "finds the position from where the `substring` matches the `string`"]
    pub fn instr(string: Expr, substring: Expr) -> Expr {
        strpos(string, substring)
    }

    #[doc = "the number of characters in the `string`"]
    pub fn length(string: Expr) -> Expr {
        character_length(string)
    }

    #[doc = "returns the first `n` characters in the `string`"]
    pub fn left(string: Expr, n: Expr) -> Expr {
        super::left().call(vec![string, n])
    }

    #[doc = "fill up a string to the length by prepending the characters"]
    pub fn lpad(args: Vec<Expr>) -> Expr {
        super::lpad().call(args)
    }

    #[doc = "finds the position from where the `substring` matches the `string`"]
    pub fn position(string: Expr, substring: Expr) -> Expr {
        strpos(string, substring)
    }

    #[doc = "reverses the `string`"]
    pub fn reverse(string: Expr) -> Expr {
        super::reverse().call(vec![string])
    }

    #[doc = "returns the last `n` characters in the `string`"]
    pub fn right(string: Expr, n: Expr) -> Expr {
        super::right().call(vec![string, n])
    }

    #[doc = "fill up a string to the length by appending the characters"]
    pub fn rpad(args: Vec<Expr>) -> Expr {
        super::rpad().call(args)
    }

    #[doc = "finds the position from where the `substring` matches the `string`"]
    pub fn strpos(string: Expr, substring: Expr) -> Expr {
        super::strpos().call(vec![string, substring])
    }

    #[doc = "substring from the `position` to the end"]
    pub fn substr(string: Expr, position: Expr) -> Expr {
        super::substr().call(vec![string, position])
    }

    #[doc = "substring from the `position` with `length` characters"]
    pub fn substring(string: Expr, position: Expr, length: Expr) -> Expr {
        super::substr().call(vec![string, position, length])
    }

    #[doc = "Returns the substring from str before count occurrences of the delimiter"]
    pub fn substr_index(string: Expr, delimiter: Expr, count: Expr) -> Expr {
        super::substr_index().call(vec![string, delimiter, count])
    }

    #[doc = "replaces the characters in `from` with the counterpart in `to`"]
    pub fn translate(string: Expr, from: Expr, to: Expr) -> Expr {
        super::translate().call(vec![string, from, to])
    }
}

///   Return a list of all functions in this package
pub fn functions() -> Vec<Arc<ScalarUDF>> {
    vec![
        character_length(),
        find_in_set(),
        left(),
        lpad(),
        reverse(),
        right(),
        rpad(),
        strpos(),
        substr(),
        substr_index(),
        translate(),
    ]
}