risingwave_sqlparser/ast/
operator.rs

1// Licensed under the Apache License, Version 2.0 (the "License");
2// you may not use this file except in compliance with the License.
3// You may obtain a copy of the License at
4//
5//     http://www.apache.org/licenses/LICENSE-2.0
6//
7// Unless required by applicable law or agreed to in writing, software
8// distributed under the License is distributed on an "AS IS" BASIS,
9// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10// See the License for the specific language governing permissions and
11// limitations under the License.
12
13use core::fmt;
14
15#[cfg(feature = "serde")]
16use serde::{Deserialize, Serialize};
17
18use super::Ident;
19
20/// Unary operators
21#[derive(Debug, Clone, PartialEq, Eq, Hash)]
22#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
23pub enum UnaryOperator {
24    Plus,
25    Minus,
26    Not,
27    /// Bitwise Not, e.g. `~9` (PostgreSQL-specific)
28    PGBitwiseNot,
29    /// Square root, e.g. `|/9` (PostgreSQL-specific)
30    PGSquareRoot,
31    /// Cube root, e.g. `||/27` (PostgreSQL-specific)
32    PGCubeRoot,
33    /// Factorial, e.g. `9!` (PostgreSQL-specific)
34    PGPostfixFactorial,
35    /// Factorial, e.g. `!!9` (PostgreSQL-specific)
36    PGPrefixFactorial,
37    /// Absolute value, e.g. `@ -9` (PostgreSQL-specific)
38    PGAbs,
39    /// Qualified, e.g. `OPERATOR(pg_catalog.+) 9` (PostgreSQL-specific)
40    PGQualified(Box<QualifiedOperator>),
41}
42
43impl fmt::Display for UnaryOperator {
44    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
45        if let UnaryOperator::PGQualified(op) = self {
46            return op.fmt(f);
47        }
48        f.write_str(match self {
49            UnaryOperator::Plus => "+",
50            UnaryOperator::Minus => "-",
51            UnaryOperator::Not => "NOT",
52            UnaryOperator::PGBitwiseNot => "~",
53            UnaryOperator::PGSquareRoot => "|/",
54            UnaryOperator::PGCubeRoot => "||/",
55            UnaryOperator::PGPostfixFactorial => "!",
56            UnaryOperator::PGPrefixFactorial => "!!",
57            UnaryOperator::PGAbs => "@",
58            UnaryOperator::PGQualified(_) => unreachable!(),
59        })
60    }
61}
62
63/// Binary operators
64#[derive(Debug, Clone, PartialEq, Eq, Hash)]
65#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
66pub enum BinaryOperator {
67    Plus,
68    Minus,
69    Multiply,
70    Divide,
71    Modulo,
72    Concat,
73    Prefix,
74    Gt,
75    Lt,
76    GtEq,
77    LtEq,
78    Spaceship,
79    Eq,
80    NotEq,
81    And,
82    Or,
83    Xor,
84    BitwiseOr,
85    BitwiseAnd,
86    BitwiseXor,
87    /// Bitwise XOR, e.g. `a # b` (PostgreSQL-specific)
88    PGBitwiseXor,
89    /// Bitwise shift left, e.g. `a << b` (PostgreSQL-specific)
90    PGBitwiseShiftLeft,
91    /// Bitwise shift right, e.g. `a >> b` (PostgreSQL-specific)
92    PGBitwiseShiftRight,
93    /// String matches regular expression (case sensitively), e.g. `a ~ b` (PostgreSQL-specific)
94    PGRegexMatch,
95    /// String matches regular expression (case insensitively), e.g. `a ~* b` (PostgreSQL-specific)
96    PGRegexIMatch,
97    /// String does not match regular expression (case sensitively), e.g. `a !~ b` (PostgreSQL-specific)
98    PGRegexNotMatch,
99    /// String does not match regular expression (case insensitively), e.g. `a !~* b` (PostgreSQL-specific)
100    PGRegexNotIMatch,
101    /// String matches pattern (case sensitively), e.g. `a ~~ b` (PostgreSQL-specific)
102    PGLikeMatch,
103    /// String matches pattern (case insensitively), e.g. `a ~~* b` (PostgreSQL-specific)
104    PGILikeMatch,
105    /// String does not match pattern (case sensitively), e.g. `a !~~ b` (PostgreSQL-specific)
106    PGNotLikeMatch,
107    /// String does not match pattern (case insensitively), e.g. `a !~~* b` (PostgreSQL-specific)
108    PGNotILikeMatch,
109    /// String "starts with", eg: `a ^@ b` (PostgreSQL-specific)
110    Arrow,
111    LongArrow,
112    HashArrow,
113    HashLongArrow,
114    HashMinus,
115    Contains,
116    Contained,
117    Exists,
118    ExistsAny,
119    ExistsAll,
120    PathMatch,
121    PathExists,
122    PGQualified(Box<QualifiedOperator>),
123}
124
125impl fmt::Display for BinaryOperator {
126    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
127        if let BinaryOperator::PGQualified(op) = self {
128            return op.fmt(f);
129        }
130        f.write_str(match self {
131            BinaryOperator::Plus => "+",
132            BinaryOperator::Minus => "-",
133            BinaryOperator::Multiply => "*",
134            BinaryOperator::Divide => "/",
135            BinaryOperator::Modulo => "%",
136            BinaryOperator::Concat => "||",
137            BinaryOperator::Prefix => "^@",
138            BinaryOperator::Gt => ">",
139            BinaryOperator::Lt => "<",
140            BinaryOperator::GtEq => ">=",
141            BinaryOperator::LtEq => "<=",
142            BinaryOperator::Spaceship => "<=>",
143            BinaryOperator::Eq => "=",
144            BinaryOperator::NotEq => "<>",
145            BinaryOperator::And => "AND",
146            BinaryOperator::Or => "OR",
147            BinaryOperator::Xor => "XOR",
148            BinaryOperator::BitwiseOr => "|",
149            BinaryOperator::BitwiseAnd => "&",
150            BinaryOperator::BitwiseXor => "^",
151            BinaryOperator::PGBitwiseXor => "#",
152            BinaryOperator::PGBitwiseShiftLeft => "<<",
153            BinaryOperator::PGBitwiseShiftRight => ">>",
154            BinaryOperator::PGRegexMatch => "~",
155            BinaryOperator::PGRegexIMatch => "~*",
156            BinaryOperator::PGRegexNotMatch => "!~",
157            BinaryOperator::PGRegexNotIMatch => "!~*",
158            BinaryOperator::PGLikeMatch => "~~",
159            BinaryOperator::PGILikeMatch => "~~*",
160            BinaryOperator::PGNotLikeMatch => "!~~",
161            BinaryOperator::PGNotILikeMatch => "!~~*",
162            BinaryOperator::Arrow => "->",
163            BinaryOperator::LongArrow => "->>",
164            BinaryOperator::HashArrow => "#>",
165            BinaryOperator::HashLongArrow => "#>>",
166            BinaryOperator::HashMinus => "#-",
167            BinaryOperator::Contains => "@>",
168            BinaryOperator::Contained => "<@",
169            BinaryOperator::Exists => "?",
170            BinaryOperator::ExistsAny => "?|",
171            BinaryOperator::ExistsAll => "?&",
172            BinaryOperator::PathMatch => "@@",
173            BinaryOperator::PathExists => "@?",
174            BinaryOperator::PGQualified(_) => unreachable!(),
175        })
176    }
177}
178
179/// Qualified custom operator
180/// <https://www.postgresql.org/docs/15/sql-expressions.html#SQL-EXPRESSIONS-OPERATOR-CALLS>
181#[derive(Debug, Clone, PartialEq, Eq, Hash)]
182#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
183pub struct QualifiedOperator {
184    pub schema: Option<Ident>,
185    pub name: String,
186}
187
188impl fmt::Display for QualifiedOperator {
189    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
190        f.write_str("OPERATOR(")?;
191        if let Some(ident) = &self.schema {
192            write!(f, "{ident}.")?;
193        }
194        f.write_str(&self.name)?;
195        f.write_str(")")
196    }
197}
risingwave_sqlparser/ast/operator.rs

risingwave_sqlparser/ast/
operator.rs
