rust_query/value/

operations.rs

use sea_query::{Alias, ExprTrait, extension::sqlite::SqliteExpr};

use crate::{
    ast::CONST_0,
    value::{BuffTyp, MyTyp},
};

use super::{EqTyp, Expr, IntoExpr, NumTyp};

impl<'column, S, T: NumTyp> Expr<'column, S, T> {
    /// Add two expressions together.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(1.into_expr().add(2)), 3);
    /// assert_eq!(txn.query_one(1.0.into_expr().add(2.0)), 3.0);
    /// # });
    /// ```
    pub fn add(&self, rhs: impl IntoExpr<'column, S, Typ = T>) -> Self {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        Expr::adhoc(move |b| lhs.build_expr(b).add(rhs.build_expr(b)))
    }

    /// Subtract one expression from another.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(1.into_expr().sub(2)), -1);
    /// assert_eq!(txn.query_one(1.0.into_expr().sub(2.0)), -1.0);
    /// # });
    /// ```
    pub fn sub(&self, rhs: impl IntoExpr<'column, S, Typ = T>) -> Self {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        Expr::adhoc(move |b| lhs.build_expr(b).sub(rhs.build_expr(b)))
    }

    /// Multiply two expressions together.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(2.into_expr().mul(3)), 6);
    /// assert_eq!(txn.query_one(2.0.into_expr().mul(3.0)), 6.0);
    /// # });
    /// ```
    pub fn mul(&self, rhs: impl IntoExpr<'column, S, Typ = T>) -> Self {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        Expr::adhoc(move |b| lhs.build_expr(b).mul(rhs.build_expr(b)))
    }

    /// Divide one expression by another.
    ///
    /// For integers, the result is truncated towards zero.
    /// See also [Expr::modulo].
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(5.into_expr().div(3)), 1);
    /// assert_eq!(txn.query_one((-5).into_expr().div(3)), -1);
    /// assert_eq!(txn.query_one(1.0.into_expr().div(2.0)), 0.5);
    /// # });
    /// ```
    pub fn div(&self, rhs: impl IntoExpr<'column, S, Typ = T>) -> Self {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        Expr::adhoc(move |b| lhs.build_expr(b).div(rhs.build_expr(b)))
    }

    /// Compute the less than operator (<) of two expressions.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(2.into_expr().lt(3)), true);
    /// assert_eq!(txn.query_one(1.into_expr().lt(1)), false);
    /// assert_eq!(txn.query_one(3.0.into_expr().lt(1.0)), false);
    /// # });
    /// ```
    pub fn lt(&self, rhs: impl IntoExpr<'column, S, Typ = T>) -> Expr<'column, S, bool> {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        Expr::adhoc(move |b| lhs.build_expr(b).lt(rhs.build_expr(b)))
    }

    /// Compute the less than or equal operator (<=) of two expressions.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(2.into_expr().lte(2)), true);
    /// assert_eq!(txn.query_one(3.0.into_expr().lte(1.0)), false);
    /// # });
    /// ```
    pub fn lte(&self, rhs: impl IntoExpr<'column, S, Typ = T>) -> Expr<'column, S, bool> {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        Expr::adhoc(move |b| lhs.build_expr(b).lte(rhs.build_expr(b)))
    }

    /// Compute the greater than operator (>) of two expressions.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(2.into_expr().gt(2)), false);
    /// assert_eq!(txn.query_one(3.0.into_expr().gt(1.0)), true);
    /// # });
    /// ```
    pub fn gt(&self, rhs: impl IntoExpr<'column, S, Typ = T>) -> Expr<'column, S, bool> {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        Expr::adhoc(move |b| lhs.build_expr(b).gt(rhs.build_expr(b)))
    }

    /// Compute the greater than or equal (>=) operator of two expressions.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(2.into_expr().gte(3)), false);
    /// assert_eq!(txn.query_one(3.0.into_expr().gte(3.0)), true);
    /// # });
    /// ```
    pub fn gte(&self, rhs: impl IntoExpr<'column, S, Typ = T>) -> Expr<'column, S, bool> {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        Expr::adhoc(move |b| lhs.build_expr(b).gte(rhs.build_expr(b)))
    }

    /// Get the maximum of two values.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(2.into_expr().max(3)), 3);
    /// assert_eq!(txn.query_one(5.0.into_expr().max(3.0)), 5.0);
    /// # });
    /// ```
    pub fn max(&self, rhs: impl IntoExpr<'column, S, Typ = T>) -> Self {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        Expr::adhoc(move |b| {
            sea_query::Expr::expr(
                sea_query::Func::cust("max")
                    .arg(lhs.build_expr(b))
                    .arg(rhs.build_expr(b)),
            )
        })
    }

    /// Get the minimum of two values.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(2.into_expr().min(3)), 2);
    /// assert_eq!(txn.query_one(5.0.into_expr().min(3.0)), 3.0);
    /// # });
    /// ```
    pub fn min(&self, rhs: impl IntoExpr<'column, S, Typ = T>) -> Self {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        Expr::adhoc(move |b| {
            sea_query::Expr::expr(
                sea_query::Func::cust("min")
                    .arg(lhs.build_expr(b))
                    .arg(rhs.build_expr(b)),
            )
        })
    }

    /// Get the sign of the expression.
    ///
    /// The result is -1, 0 or 1 depending on if the expression is
    /// negative, zero or positive.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(2.into_expr().sign()), 1);
    /// assert_eq!(txn.query_one((-5.0).into_expr().sign()), -1);
    /// assert_eq!(txn.query_one((-0.0).into_expr().sign()), 0);
    /// # });
    /// ```
    pub fn sign(&self) -> Expr<'column, S, i64> {
        let lhs = self.inner.clone();
        Expr::adhoc(move |b| {
            sea_query::Expr::expr(sea_query::Func::cust("sign").arg(lhs.build_expr(b)))
        })
    }

    /// Get the absolute value of the expression.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(2.into_expr().abs()), 2);
    /// assert_eq!(txn.query_one((-5.0).into_expr().abs()), 5.0);
    /// # });
    /// ```
    pub fn abs(&self) -> Self {
        let lhs = self.inner.clone();
        Expr::adhoc(move |b| {
            sea_query::Expr::expr(sea_query::Func::cust("abs").arg(lhs.build_expr(b)))
        })
    }

    /// Check if a value is between two other values.
    ///
    /// The range is inclusive on both sides.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(2.into_expr().between(2, 3)), true);
    /// assert_eq!(txn.query_one(3.into_expr().between(2, 3)), true);
    /// assert_eq!(txn.query_one(5.into_expr().between(2, 3)), false);
    /// assert_eq!(txn.query_one(1.into_expr().between(2, 3)), false);
    /// # });
    /// ```
    pub fn between(
        &self,
        low: impl IntoExpr<'column, S, Typ = T>,
        high: impl IntoExpr<'column, S, Typ = T>,
    ) -> Expr<'column, S, bool> {
        let lhs = self.inner.clone();
        let low = low.into_expr().inner;
        let high = high.into_expr().inner;
        Expr::adhoc(move |b| {
            lhs.build_expr(b)
                .between(low.build_expr(b), high.build_expr(b))
        })
    }
}

impl<'column, S, T: EqTyp + 'static> Expr<'column, S, T> {
    /// Check whether two expressions are equal.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(2.into_expr().eq(2)), true);
    /// assert_eq!(txn.query_one(3.0.into_expr().eq(3.0)), true);
    /// assert_eq!(txn.query_one("test".into_expr().eq("test")), true);
    /// assert_eq!(txn.query_one(b"test".into_expr().eq(b"test" as &[u8])), true);
    /// assert_eq!(txn.query_one(false.into_expr().eq(false)), true);
    ///
    /// assert_eq!(txn.query_one(1.into_expr().eq(2)), false);
    /// # });
    /// ```
    pub fn eq(&self, rhs: impl IntoExpr<'column, S, Typ = T>) -> Expr<'column, S, bool> {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        Expr::adhoc(move |b| lhs.build_expr(b).is(rhs.build_expr(b)))
    }

    /// Check whether two expressions are not equal.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(2.into_expr().neq(2)), false);
    /// assert_eq!(txn.query_one(3.0.into_expr().neq(3.1)), true);
    /// assert_eq!(txn.query_one("test".into_expr().neq("test")), false);
    /// assert_eq!(txn.query_one(b"test".into_expr().neq(b"test" as &[u8])), false);
    /// assert_eq!(txn.query_one(false.into_expr().neq(false)), false);
    ///
    /// assert_eq!(txn.query_one(1.into_expr().neq(2)), true);
    /// # });
    /// ```
    pub fn neq(&self, rhs: impl IntoExpr<'column, S, Typ = T>) -> Expr<'column, S, bool> {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        Expr::adhoc(move |b| lhs.build_expr(b).is_not(rhs.build_expr(b)))
    }
}

impl<'column, S> Expr<'column, S, bool> {
    /// Checks whether an expression is false.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(true.into_expr().not()), false);
    /// assert_eq!(txn.query_one(false.into_expr().not()), true);
    /// # });
    /// ```
    pub fn not(&self) -> Self {
        let val = self.inner.clone();
        Expr::adhoc(move |b| val.build_expr(b).not())
    }

    /// Check if two expressions are both true.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(true.into_expr().and(true)), true);
    /// assert_eq!(txn.query_one(false.into_expr().and(true)), false);
    /// assert_eq!(txn.query_one(false.into_expr().and(false)), false);
    /// # });
    /// ```
    pub fn and(&self, rhs: impl IntoExpr<'column, S, Typ = bool>) -> Self {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        Expr::adhoc(move |b| lhs.build_expr(b).and(rhs.build_expr(b)))
    }

    /// Check if one of two expressions is true.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(true.into_expr().or(true)), true);
    /// assert_eq!(txn.query_one(false.into_expr().or(true)), true);
    /// assert_eq!(txn.query_one(false.into_expr().or(false)), false);
    /// # });
    /// ```
    pub fn or(&self, rhs: impl IntoExpr<'column, S, Typ = bool>) -> Self {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        Expr::adhoc(move |b| lhs.build_expr(b).or(rhs.build_expr(b)))
    }
}

impl<'column, S, Typ: MyTyp> Expr<'column, S, Option<Typ>> {
    /// Use the first expression if it is [Some], otherwise use the second expression.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(Some(10).into_expr().unwrap_or(5)), 10);
    /// assert_eq!(txn.query_one(None::<String>.into_expr().unwrap_or("foo")), "foo");
    /// # });
    /// ```
    pub fn unwrap_or(&self, rhs: impl IntoExpr<'column, S, Typ = Typ>) -> Expr<'column, S, Typ> {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        let maybe_optional = rhs.maybe_optional;
        Expr::adhoc_promise(
            move |b| sea_query::Expr::expr(lhs.build_expr(b)).if_null(rhs.build_expr(b)),
            maybe_optional,
        )
    }

    /// Check that the expression is [Some].
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(Some(10).into_expr().is_some()), true);
    /// assert_eq!(txn.query_one(None::<i64>.into_expr().is_some()), false);
    /// # });
    /// ```
    pub fn is_some(&self) -> Expr<'column, S, bool> {
        let val = self.inner.clone();
        Expr::adhoc(move |b| val.build_expr(b).is_not_null())
    }

    /// Check that the expression is [None].
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(Some(10).into_expr().is_none()), false);
    /// assert_eq!(txn.query_one(None::<i64>.into_expr().is_none()), true);
    /// # });
    /// ```
    pub fn is_none(&self) -> Expr<'column, S, bool> {
        let val = self.inner.clone();
        Expr::adhoc(move |b| val.build_expr(b).is_null())
    }
}

impl<'column, S> Expr<'column, S, i64> {
    #[deprecated(note = "Renamed to [Self::to_f64]")]
    pub fn as_float(&self) -> Expr<'column, S, f64> {
        self.to_f64()
    }

    /// Convert the [i64] expression to [f64] type.
    ///
    /// The conversion may not be lossless for integers larger than 2^53 or smaller than (-2^53).
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(10.into_expr().as_float()), 10.0);
    /// # });
    /// ```
    pub fn to_f64(&self) -> Expr<'column, S, f64> {
        let val = self.inner.clone();
        Expr::adhoc(move |b| val.build_expr(b).cast_as(Alias::new("REAL")))
    }

    /// Calculate the remainder for integer division.
    ///
    /// The remainder is the missing part after division.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(5.into_expr().div(3)), 1);
    /// assert_eq!(txn.query_one(5.into_expr().modulo(3)), 2);
    /// assert_eq!(txn.query_one((-5).into_expr().div(3)), -1);
    /// assert_eq!(txn.query_one((-5).into_expr().modulo(3)), -2);
    /// # });
    /// ```
    pub fn modulo(&self, rhs: impl IntoExpr<'column, S, Typ = i64>) -> Self {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        Expr::adhoc(move |b| lhs.build_expr(b).modulo(rhs.build_expr(b)))
    }

    /// Get the current timestamp as milliseconds since unix epoch.
    pub fn unix_epoch() -> Self {
        #[expect(deprecated)]
        crate::value::UnixEpoch.into_expr()
    }
}

impl<'column, S> Expr<'column, S, f64> {
    #[deprecated(note = "Renamed to [Self::to_i64]")]
    pub fn truncate(&self) -> Expr<'column, S, i64> {
        self.to_i64()
    }

    /// Convert the [f64] expression to [i64] type.
    ///
    /// Always rounds towards zero for floats that are not already an integer.
    ///
    /// Values outside the range `i64::MIN..=i64::MAX`, will be converted to
    /// the closest integer in that range.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(10.9.into_expr().truncate()), 10);
    /// assert_eq!(txn.query_one((-10.9).into_expr().truncate()), -10);
    /// assert_eq!(txn.query_one((342143124.0).into_expr().truncate()), 342143124);
    /// assert_eq!(txn.query_one((f64::MIN).into_expr().truncate()), i64::MIN);
    /// assert_eq!(txn.query_one((f64::NEG_INFINITY).into_expr().truncate()), i64::MIN);
    /// # });
    /// ```
    pub fn to_i64(&self) -> Expr<'column, S, i64> {
        let val = self.inner.clone();
        Expr::adhoc(move |b| val.build_expr(b).cast_as(Alias::new("INTEGER")))
    }

    /// Round the [f64] expression down.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(10.9.into_expr().floor()), 10.0);
    /// assert_eq!(txn.query_one((-10.9).into_expr().floor()), -11.0);
    /// assert_eq!(txn.query_one((f64::MIN).into_expr().floor()), f64::MIN);
    /// assert_eq!(txn.query_one((f64::NEG_INFINITY).into_expr().floor()), f64::NEG_INFINITY);
    /// # });
    /// ```
    pub fn floor(&self) -> Expr<'column, S, f64> {
        let val = self.inner.clone();
        Expr::adhoc(move |b| sea_query::Func::cust("floor").arg(val.build_expr(b)).into())
    }

    /// Round the [f64] expression up.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(10.9.into_expr().ceil()), 11.0);
    /// assert_eq!(txn.query_one((-10.9).into_expr().ceil()), -10.0);
    /// assert_eq!(txn.query_one((f64::MIN).into_expr().ceil()), f64::MIN);
    /// assert_eq!(txn.query_one((f64::NEG_INFINITY).into_expr().ceil()), f64::NEG_INFINITY);
    /// # });
    /// ```
    pub fn ceil(&self) -> Expr<'column, S, f64> {
        let val = self.inner.clone();
        Expr::adhoc(move |b| sea_query::Func::cust("ceil").arg(val.build_expr(b)).into())
    }

    /// Round the [f64] expression to the specified precision.
    ///
    /// Precision specifies the number of decimal places to keep.
    /// A negative precision is treated as zero.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(10.85.into_expr().round_with_precision(0)), 11.0);
    /// assert_eq!(txn.query_one((-10.85).into_expr().round_with_precision(0)), -11.0);
    /// assert_eq!(txn.query_one(10.85.into_expr().round_with_precision(1)), 10.8);
    /// assert_eq!(txn.query_one((-10.85).into_expr().round_with_precision(1)), -10.8);
    /// assert_eq!(txn.query_one((f64::MIN).into_expr().round_with_precision(0)), f64::MIN);
    /// assert_eq!(txn.query_one((f64::NEG_INFINITY).into_expr().round_with_precision(0)), f64::NEG_INFINITY);
    /// # });
    /// ```
    pub fn round_with_precision(&self, precision: impl IntoExpr<'column, S, Typ = i64>) -> Self {
        let val = self.inner.clone();
        let precision = precision.into_expr().inner;
        Expr::adhoc(move |b| {
            sea_query::Func::round_with_precision(val.build_expr(b), precision.build_expr(b)).into()
        })
    }
}

impl<'column, S> Expr<'column, S, String> {
    /// Check if the expression starts with the string pattern.
    ///
    /// Matches case-sensitive. The pattern gets automatically escaped.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one("hello world".into_expr().starts_with("hello")), true);
    /// assert_eq!(txn.query_one("hello world".into_expr().starts_with("Hello")), false);
    /// # });
    /// ```
    pub fn starts_with(&self, pattern: impl AsRef<str>) -> Expr<'column, S, bool> {
        self.glob(format!("{}*", escape_glob(pattern)))
    }

    /// Check if the expression ends with the string pattern.
    ///
    /// Matches case-sensitive. The pattern gets automatically escaped.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one("hello world".into_expr().ends_with("world")), true);
    /// assert_eq!(txn.query_one("hello world".into_expr().ends_with("World")), false);
    /// # });
    /// ```
    pub fn ends_with(&self, pattern: impl AsRef<str>) -> Expr<'column, S, bool> {
        self.glob(format!("*{}", escape_glob(pattern)))
    }

    /// Check if the expression contains the string pattern.
    ///
    /// Matches case-sensitive. The pattern gets automatically escaped.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one("rhubarb".into_expr().contains("bar")), true);
    /// assert_eq!(txn.query_one("rhubarb".into_expr().contains("Bar")), false);
    /// # });
    /// ```
    #[doc(alias = "instr")]
    pub fn contains(&self, rhs: impl IntoExpr<'column, S, Typ = String>) -> Expr<'column, S, bool> {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        Expr::adhoc(move |b| {
            sea_query::Expr::expr(
                sea_query::Func::cust("instr")
                    .arg(lhs.build_expr(b))
                    .arg(rhs.build_expr(b)),
            )
            .is_not(CONST_0)
        })
    }

    /// Replace all occurences of a string with another string.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one("very,cool,list".into_expr().replace(",", "::")), "very::cool::list");
    /// assert_eq!(txn.query_one("rarar".into_expr().replace("rar", "rer")), "rerar");
    /// # });
    /// ```
    pub fn replace(
        &self,
        pattern: impl IntoExpr<'column, S, Typ = String>,
        new: impl IntoExpr<'column, S, Typ = String>,
    ) -> Self {
        let lhs = self.inner.clone();
        let pat = pattern.into_expr().inner;
        let new = new.into_expr().inner;
        Expr::adhoc(move |b| {
            sea_query::Func::cust("replace")
                .args([lhs.build_expr(b), pat.build_expr(b), new.build_expr(b)])
                .into()
        })
    }

    /// Removes all characters from a set from the start of a string.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one("abacda".into_expr().ltrim("ab")), "cda");
    /// # });
    /// ```
    pub fn ltrim(&self, char_set: impl IntoExpr<'column, S, Typ = String>) -> Self {
        let lhs = self.inner.clone();
        let char_set = char_set.into_expr().inner;
        Expr::adhoc(move |b| {
            sea_query::Func::cust("ltrim")
                .args([lhs.build_expr(b), char_set.build_expr(b)])
                .into()
        })
    }

    /// Removes all characters from a set from the end of a string.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one("adcaba".into_expr().rtrim("ab")), "adc");
    /// # });
    /// ```
    pub fn rtrim(&self, char_set: impl IntoExpr<'column, S, Typ = String>) -> Self {
        let lhs = self.inner.clone();
        let char_set = char_set.into_expr().inner;
        Expr::adhoc(move |b| {
            sea_query::Func::cust("rtrim")
                .args([lhs.build_expr(b), char_set.build_expr(b)])
                .into()
        })
    }

    /// Removes all characters from a set from both the start and end of a string.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one("ffzfzf".into_expr().trim("f")), "zfz");
    /// # });
    /// ```
    pub fn trim(&self, char_set: impl IntoExpr<'column, S, Typ = String>) -> Self {
        let lhs = self.inner.clone();
        let char_set = char_set.into_expr().inner;
        Expr::adhoc(move |b| {
            sea_query::Func::cust("trim")
                .args([lhs.build_expr(b), char_set.build_expr(b)])
                .into()
        })
    }

    /// Check if the expression matches the pattern [sqlite docs](https://www.sqlite.org/lang_expr.html#like).
    ///
    /// This is a case-sensitive version of [like](Self::like). It uses Unix file globbing syntax for wild
    /// cards. `*` matches any sequence of characters and `?` matches any single character. `[0-9]` matches
    /// any single digit and `[a-z]` matches any single lowercase letter. `^` negates the pattern.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one("hello world".into_expr().glob("?ello*")), true);
    /// assert_eq!(txn.query_one("hello world".into_expr().glob("Hell*")), false);
    /// # });
    /// ```
    pub fn glob(&self, rhs: impl IntoExpr<'column, S, Typ = String>) -> Expr<'column, S, bool> {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        Expr::adhoc(move |b| sea_query::Expr::expr(lhs.build_expr(b)).glob(rhs.build_expr(b)))
    }

    /// Check if the expression matches the pattern [sqlite docs](https://www.sqlite.org/lang_expr.html#like).
    ///
    /// As noted in the docs, it is **case-insensitive** for ASCII characters. Other characters are case-sensitive.
    /// For creating patterns it uses `%` as a wildcard for any sequence of characters and `_` for any single character.
    /// Special characters should be escaped with `\`.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one("hello world".into_expr().like("HELLO%")), true);
    /// assert_eq!(txn.query_one("hello world".into_expr().like("he_o%")), false);
    /// # });
    /// ```
    pub fn like(&self, pattern: impl Into<String>) -> Expr<'column, S, bool> {
        let lhs = self.inner.clone();
        let rhs = pattern.into();
        Expr::adhoc(move |b| {
            sea_query::Expr::expr(lhs.build_expr(b))
                .like(sea_query::LikeExpr::new(&rhs).escape('\\'))
        })
    }

    /// Concatenate two strings.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one("hello ".into_expr().concat("world").concat("!")), "hello world!");
    /// # });
    /// ```
    pub fn concat(&self, rhs: impl IntoExpr<'column, S, Typ = String>) -> Self {
        let lhs = self.inner.clone();
        let rhs = rhs.into_expr().inner;
        Expr::adhoc(move |b| {
            sea_query::Expr::expr(
                sea_query::Func::cust("concat")
                    .arg(lhs.build_expr(b))
                    .arg(rhs.build_expr(b)),
            )
        })
    }

    /// Convert ascii to lowercase.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one("Hello".into_expr().lower()), "hello");
    /// assert_eq!(txn.query_one("WHAT".into_expr().lower()), "what");
    /// # });
    /// ```
    pub fn lower(&self) -> Self {
        let lhs = self.inner.clone();
        Expr::adhoc(move |b| {
            sea_query::Expr::expr(sea_query::Func::cust("lower").arg(lhs.build_expr(b)))
        })
    }

    /// Convert ascii to uppercase.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one("Hello".into_expr().upper()), "HELLO");
    /// assert_eq!(txn.query_one("what".into_expr().upper()), "WHAT");
    /// # });
    /// ```
    pub fn upper(&self) -> Self {
        let lhs = self.inner.clone();
        Expr::adhoc(move |b| {
            sea_query::Expr::expr(sea_query::Func::cust("upper").arg(lhs.build_expr(b)))
        })
    }

    /// The number of unicode code points in the string.
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one("€".into_expr().char_len()), 1);
    /// assert_eq!(txn.query_one("what".into_expr().char_len()), 4);
    /// # });
    /// ```
    pub fn char_len(&self) -> Expr<'column, S, i64> {
        let lhs = self.inner.clone();
        Expr::adhoc(move |b| {
            sea_query::Expr::expr(sea_query::Func::cust("length").arg(lhs.build_expr(b)))
        })
    }
}

impl<'column, S, T: BuffTyp> Expr<'column, S, T> {
    /// The length of the value in bytes.
    ///
    /// The byte length of strings can depend on the encoding (UTF-8 or UTF-16).
    ///
    /// ```
    /// # use rust_query::IntoExpr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one("€".into_expr().byte_len()), 3);
    /// assert_eq!(txn.query_one("what".into_expr().byte_len()), 4);
    /// assert_eq!(txn.query_one(vec![1, 2].into_expr().byte_len()), 2);
    /// # });
    /// ```
    pub fn byte_len(&self) -> Expr<'column, S, i64> {
        let lhs = self.inner.clone();
        Expr::adhoc(move |b| {
            sea_query::Expr::expr(sea_query::Func::cust("octet_length").arg(lhs.build_expr(b)))
        })
    }
}

impl<'column, S> Expr<'column, S, Vec<u8>> {
    /// Create a new blob of zero bytes of the specified length.
    ///
    /// ```
    /// # use rust_query::Expr;
    /// # rust_query::private::doctest::get_txn(|txn| {
    /// assert_eq!(txn.query_one(Expr::zero_blob(40)), vec![0; 40]);
    /// # });
    /// ```
    pub fn zero_blob(len: impl IntoExpr<'column, S, Typ = i64>) -> Self {
        let len = len.into_expr().inner;
        Expr::adhoc(move |b| {
            sea_query::Expr::expr(sea_query::Func::cust("zeroblob").arg(len.build_expr(b)))
        })
    }
}

// This is a copy of the function from the glob crate https://github.com/rust-lang/glob/blob/49ee1e92bd6e8c5854c0b339634f9b4b733aba4f/src/lib.rs#L720-L737.
fn escape_glob(s: impl AsRef<str>) -> String {
    let mut escaped = String::new();
    for c in s.as_ref().chars() {
        match c {
            // note that ! does not need escaping because it is only special
            // inside brackets
            '?' | '*' | '[' | ']' => {
                escaped.push('[');
                escaped.push(c);
                escaped.push(']');
            }
            c => {
                escaped.push(c);
            }
        }
    }
    escaped
}