drizzle-postgres 0.1.9

A type-safe SQL query builder for Rust
Documentation 
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
153
154

//! `PostgreSQL` regular expression operators.
//!
//! Provides type-safe access to `PostgreSQL` regex operators:
//! - `~` (matches regex, case-sensitive)
//! - `~*` (matches regex, case-insensitive)
//! - `!~` (does not match regex, case-sensitive)
//! - `!~*` (does not match regex, case-insensitive)

use crate::values::PostgresValue;
use drizzle_core::expr::{Expr, NonNull, SQLExpr, Scalar};
use drizzle_core::sql::{SQL, SQLChunk};
use drizzle_types::postgres::types::Boolean;

/// `PostgreSQL` `~` operator - case-sensitive regex match.
///
/// # Example
///
/// ```
/// # use drizzle_postgres::expr::regex_match;
/// # use drizzle_core::{SQL, ToSQL};
/// # use drizzle_postgres::values::PostgresValue;
/// let name = SQL::<PostgresValue>::raw("name");
/// let cond = regex_match(name, "^[A-Z]");
/// assert!(cond.to_sql().sql().contains("~"));
/// ```
pub fn regex_match<'a, E>(
    expr: E,
    pattern: &'a str,
) -> SQLExpr<'a, PostgresValue<'a>, Boolean, NonNull, Scalar>
where
    E: Expr<'a, PostgresValue<'a>>,
{
    SQLExpr::new(
        expr.to_sql()
            .push(SQLChunk::Raw("~".into()))
            .append(SQL::param(PostgresValue::Text(pattern.into()))),
    )
}

/// `PostgreSQL` `~*` operator - case-insensitive regex match.
///
/// # Example
///
/// ```
/// # use drizzle_postgres::expr::regex_match_ci;
/// # use drizzle_core::{SQL, ToSQL};
/// # use drizzle_postgres::values::PostgresValue;
/// let name = SQL::<PostgresValue>::raw("name");
/// let cond = regex_match_ci(name, "^john");
/// assert!(cond.to_sql().sql().contains("~*"));
/// ```
pub fn regex_match_ci<'a, E>(
    expr: E,
    pattern: &'a str,
) -> SQLExpr<'a, PostgresValue<'a>, Boolean, NonNull, Scalar>
where
    E: Expr<'a, PostgresValue<'a>>,
{
    SQLExpr::new(
        expr.to_sql()
            .push(SQLChunk::Raw("~*".into()))
            .append(SQL::param(PostgresValue::Text(pattern.into()))),
    )
}

/// `PostgreSQL` `!~` operator - case-sensitive regex non-match.
///
/// # Example
///
/// ```
/// # use drizzle_postgres::expr::regex_not_match;
/// # use drizzle_core::{SQL, ToSQL};
/// # use drizzle_postgres::values::PostgresValue;
/// let name = SQL::<PostgresValue>::raw("name");
/// let cond = regex_not_match(name, "^[0-9]");
/// assert!(cond.to_sql().sql().contains("!~"));
/// ```
pub fn regex_not_match<'a, E>(
    expr: E,
    pattern: &'a str,
) -> SQLExpr<'a, PostgresValue<'a>, Boolean, NonNull, Scalar>
where
    E: Expr<'a, PostgresValue<'a>>,
{
    SQLExpr::new(
        expr.to_sql()
            .push(SQLChunk::Raw("!~".into()))
            .append(SQL::param(PostgresValue::Text(pattern.into()))),
    )
}

/// `PostgreSQL` `!~*` operator - case-insensitive regex non-match.
///
/// # Example
///
/// ```
/// # use drizzle_postgres::expr::regex_not_match_ci;
/// # use drizzle_core::{SQL, ToSQL};
/// # use drizzle_postgres::values::PostgresValue;
/// let name = SQL::<PostgresValue>::raw("name");
/// let cond = regex_not_match_ci(name, "^admin");
/// assert!(cond.to_sql().sql().contains("!~*"));
/// ```
pub fn regex_not_match_ci<'a, E>(
    expr: E,
    pattern: &'a str,
) -> SQLExpr<'a, PostgresValue<'a>, Boolean, NonNull, Scalar>
where
    E: Expr<'a, PostgresValue<'a>>,
{
    SQLExpr::new(
        expr.to_sql()
            .push(SQLChunk::Raw("!~*".into()))
            .append(SQL::param(PostgresValue::Text(pattern.into()))),
    )
}

/// Extension trait providing method-based regex operators for `PostgreSQL` expressions.
pub trait RegexExprExt<'a>: Expr<'a, PostgresValue<'a>> + Sized {
    /// Case-sensitive regex match (`~` operator).
    fn regex_match(
        self,
        pattern: &'a str,
    ) -> SQLExpr<'a, PostgresValue<'a>, Boolean, NonNull, Scalar> {
        regex_match(self, pattern)
    }

    /// Case-insensitive regex match (`~*` operator).
    fn regex_match_ci(
        self,
        pattern: &'a str,
    ) -> SQLExpr<'a, PostgresValue<'a>, Boolean, NonNull, Scalar> {
        regex_match_ci(self, pattern)
    }

    /// Case-sensitive regex non-match (`!~` operator).
    fn regex_not_match(
        self,
        pattern: &'a str,
    ) -> SQLExpr<'a, PostgresValue<'a>, Boolean, NonNull, Scalar> {
        regex_not_match(self, pattern)
    }

    /// Case-insensitive regex non-match (`!~*` operator).
    fn regex_not_match_ci(
        self,
        pattern: &'a str,
    ) -> SQLExpr<'a, PostgresValue<'a>, Boolean, NonNull, Scalar> {
        regex_not_match_ci(self, pattern)
    }
}

/// Blanket implementation for all `PostgreSQL` `Expr` types.
impl<'a, E: Expr<'a, PostgresValue<'a>>> RegexExprExt<'a> for E {}