Fix most type-defs for #[auto_type] by cleaning up all the type defs

Author: weiznich

diesel/src/expression/exists.rs

@@ -4,7 +4,7 @@
 use crate::backend::{sql_dialect, Backend, SqlDialect};
 use crate::expression::subselect::Subselect;
 use crate::expression::{AppearsOnTable, Expression, SelectableExpression, ValidGrouping};
-use crate::helper_types::exists;
+use crate::helper_types;
 use crate::query_builder::*;
 use crate::result::QueryResult;
 use crate::sql_types::Bool;
@@ -32,7 +32,7 @@ use crate::sql_types::Bool;
 /// assert_eq!(Ok(false), jim_exists);
 /// # }
 /// ```
-pub fn exists<T>(query: T) -> exists<T> {
+pub fn exists<T>(query: T) -> helper_types::Exists<T> {
     Exists {
         subselect: Subselect::new(query),
     }

diesel/src/expression/functions/helper_types.rs

@@ -5,19 +5,43 @@ use crate::expression::grouped::Grouped;
 use crate::expression::operators;
 
 /// The return type of [`not(expr)`](crate::dsl::not())
-pub type not<Expr> = operators::Not<Grouped<Expr>>;
+pub type Not<Expr> = operators::Not<Grouped<Expr>>;
+
+#[doc(hidden)]
+#[deprecated(note = "use `dsl::Not` instead")]
+pub type not<Expr> = Not<Expr>;
 
 /// The return type of [`max(expr)`](crate::dsl::max())
-pub type max<Expr> = super::aggregate_ordering::max::HelperType<SqlTypeOf<Expr>, Expr>;
+pub type Max<Expr> = super::aggregate_ordering::max::HelperType<SqlTypeOf<Expr>, Expr>;
+
+#[doc(hidden)]
+#[deprecated(note = "use `dsl::Max` instead")]
+pub type max<Expr> = Max<Expr>;
 
 /// The return type of [`min(expr)`](crate::dsl::min())
-pub type min<Expr> = super::aggregate_ordering::min::HelperType<SqlTypeOf<Expr>, Expr>;
+pub type Min<Expr> = super::aggregate_ordering::min::HelperType<SqlTypeOf<Expr>, Expr>;
+
+#[doc(hidden)]
+#[deprecated(note = "use `dsl::Min` instead")]
+pub type min<Expr> = Min<Expr>;
 
 /// The return type of [`sum(expr)`](crate::dsl::sum())
-pub type sum<Expr> = super::aggregate_folding::sum::HelperType<SqlTypeOf<Expr>, Expr>;
+pub type Sum<Expr> = super::aggregate_folding::sum::HelperType<SqlTypeOf<Expr>, Expr>;
+
+#[doc(hidden)]
+#[deprecated(note = "use `dsl::Not` instead")]
+pub type sum<Expr> = Sum<Expr>;
 
 /// The return type of [`avg(expr)`](crate::dsl::avg())
-pub type avg<Expr> = super::aggregate_folding::avg::HelperType<SqlTypeOf<Expr>, Expr>;
+pub type Avg<Expr> = super::aggregate_folding::avg::HelperType<SqlTypeOf<Expr>, Expr>;
+
+#[doc(hidden)]
+#[deprecated(note = "use `dsl::Not` instead")]
+pub type avg<Expr> = Avg<Expr>;
 
 /// The return type of [`exists(expr)`](crate::dsl::exists())
-pub type exists<Expr> = crate::expression::exists::Exists<Expr>;
+pub type Exists<Expr> = crate::expression::exists::Exists<Expr>;
+
+#[doc(hidden)]
+#[deprecated(note = "use `dsl::Exists` instead")]
+pub type exists<Expr> = Exists<Expr>;

diesel/src/expression/helper_types.rs

@@ -25,6 +25,9 @@ pub type Eq<Lhs, Rhs> = Grouped<super::operators::Eq<Lhs, AsExpr<Rhs, Lhs>>>;
 /// [`lhs.ne(rhs)`](crate::expression_methods::ExpressionMethods::ne())
 pub type NotEq<Lhs, Rhs> = Grouped<super::operators::NotEq<Lhs, AsExpr<Rhs, Lhs>>>;
 
+#[doc(hidden)]
+pub type Ne<Lhs, Rhs> = NotEq<Lhs, Rhs>;
+
 /// The return type of
 /// [`lhs.eq_any(rhs)`](crate::expression_methods::ExpressionMethods::eq_any())
 pub type EqAny<Lhs, Rhs> = Grouped<In<Lhs, <Rhs as AsInExpression<SqlTypeOf<Lhs>>>::InExpression>>;
@@ -34,6 +37,9 @@ pub type EqAny<Lhs, Rhs> = Grouped<In<Lhs, <Rhs as AsInExpression<SqlTypeOf<Lhs>
 pub type NeAny<Lhs, Rhs> =
     Grouped<NotIn<Lhs, <Rhs as AsInExpression<SqlTypeOf<Lhs>>>::InExpression>>;
 
+#[doc(hidden)] // required for `#[auto_type]`
+pub type NeAll<Lhs, Rhs> = NeAny<Lhs, Rhs>;
+
 /// The return type of
 /// [`expr.is_null()`](crate::expression_methods::ExpressionMethods::is_null())
 pub type IsNull<Expr> = Grouped<super::operators::IsNull<Expr>>;
@@ -50,6 +56,9 @@ pub type Gt<Lhs, Rhs> = Grouped<super::operators::Gt<Lhs, AsExpr<Rhs, Lhs>>>;
 /// [`lhs.ge(rhs)`](crate::expression_methods::ExpressionMethods::ge())
 pub type GtEq<Lhs, Rhs> = Grouped<super::operators::GtEq<Lhs, AsExpr<Rhs, Lhs>>>;
 
+#[doc(hidden)] // required for `#[auto_type]`
+pub type Ge<Lhs, Rhs> = GtEq<Lhs, Rhs>;
+
 /// The return type of
 /// [`lhs.lt(rhs)`](crate::expression_methods::ExpressionMethods::lt())
 pub type Lt<Lhs, Rhs> = Grouped<super::operators::Lt<Lhs, AsExpr<Rhs, Lhs>>>;
@@ -58,6 +67,9 @@ pub type Lt<Lhs, Rhs> = Grouped<super::operators::Lt<Lhs, AsExpr<Rhs, Lhs>>>;
 /// [`lhs.le(rhs)`](crate::expression_methods::ExpressionMethods::le())
 pub type LtEq<Lhs, Rhs> = Grouped<super::operators::LtEq<Lhs, AsExpr<Rhs, Lhs>>>;
 
+#[doc(hidden)] // required for `#[auto_type]`
+pub type Le<Lhs, Rhs> = LtEq<Lhs, Rhs>;
+
 /// The return type of
 /// [`lhs.between(lower, upper)`](crate::expression_methods::ExpressionMethods::between())
 pub type Between<Lhs, Lower, Upper> = Grouped<

diesel/src/expression/mod.rs

@@ -70,16 +70,29 @@ pub(crate) mod dsl {
     pub use crate::pg::expression::dsl::*;
 
     /// The return type of [`count(expr)`](crate::dsl::count())
-    pub type count<Expr> = super::count::count::HelperType<SqlTypeOf<Expr>, Expr>;
+    pub type Count<Expr> = super::count::count::HelperType<SqlTypeOf<Expr>, Expr>;
+    #[doc(hidden)]
+    #[deprecated(note = "use `dsl::Count` instead")]
+    pub type count<Expr> = Count<Expr>;
 
     /// The return type of [`count_star()`](crate::dsl::count_star())
-    pub type count_star = super::count::CountStar;
+    pub type CountStar = super::count::CountStar;
+    #[doc(hidden)]
+    #[deprecated(note = "use `dsl::CountStar` instead")]
+    pub type count_star = CountStar;
 
     /// The return type of [`count_distinct()`](crate::dsl::count_distinct())
-    pub type count_distinct<Expr> = super::count::CountDistinct<SqlTypeOf<Expr>, Expr>;
+    pub type CountDistinct<Expr> = super::count::CountDistinct<SqlTypeOf<Expr>, Expr>;
+
+    #[doc(hidden)]
+    #[deprecated(note = "use `dsl::CountDistinct` instead")]
+    pub type count_distinct<Expr> = CountDistinct<Expr>;
 
     /// The return type of [`date(expr)`](crate::dsl::date())
-    pub type date<Expr> = super::functions::date_and_time::date::HelperType<Expr>;
+    pub type Date<Expr> = super::functions::date_and_time::date::HelperType<Expr>;
+    #[doc(hidden)]
+    #[deprecated(note = "Use `dsl::Date` instead")]
+    pub type date<Expr> = Date<Expr>;
 
     #[cfg(feature = "mysql_backend")]
     pub use crate::mysql::query_builder::DuplicatedKeys;

diesel/src/expression/not.rs

@@ -1,6 +1,6 @@
 use crate::expression::grouped::Grouped;
 use crate::expression::Expression;
-use crate::helper_types::not;
+use crate::helper_types;
 use crate::sql_types::BoolOrNullableBool;
 
 /// Creates a SQL `NOT` expression
@@ -23,7 +23,7 @@ use crate::sql_types::BoolOrNullableBool;
 /// assert_eq!(Ok(2), users_not_with_name.first(connection));
 /// # }
 /// ```
-pub fn not<T>(expr: T) -> not<T>
+pub fn not<T>(expr: T) -> helper_types::Not<T>
 where
     T: Expression,
     <T as Expression>::SqlType: BoolOrNullableBool,

diesel/src/lib.rs

@@ -315,7 +315,7 @@ pub use diesel_derives::{
 
 pub use diesel_derives::MultiConnection;
 
-#[allow(unknown_lints, ambiguous_glob_reexports)]
+#[allow(unknown_lints, ambiguous_glob_reexports, missing_docs)]
 pub mod dsl {
     //! Includes various helper types and bare functions which are named too
     //! generically to be included in prelude, but are often used when using Diesel.
@@ -335,6 +335,7 @@ pub mod dsl {
     pub use diesel_derives::auto_type;
 }
 
+#[allow(missing_docs)]
 pub mod helper_types {
     //! Provide helper types for concisely writing the return type of functions.
     //! As with iterators, it is unfortunately difficult to return a partially
@@ -407,10 +408,10 @@ pub mod helper_types {
     pub type ThenOrderBy<Source, Ordering> = <Source as ThenOrderDsl<Ordering>>::Output;
 
     /// Represents the return type of [`.limit()`](crate::prelude::QueryDsl::limit)
-    pub type Limit<Source> = <Source as LimitDsl>::Output;
+    pub type Limit<Source, DummyArg = i64> = <Source as LimitDsl<DummyArg>>::Output;
 
     /// Represents the return type of [`.offset()`](crate::prelude::QueryDsl::offset)
-    pub type Offset<Source> = <Source as OffsetDsl>::Output;
+    pub type Offset<Source, DummyArg = i64> = <Source as OffsetDsl<DummyArg>>::Output;
 
     /// Represents the return type of [`.inner_join(rhs)`](crate::prelude::QueryDsl::inner_join)
     pub type InnerJoin<Source, Rhs> =
@@ -622,6 +623,53 @@ pub mod helper_types {
     #[deprecated(note = "Use `LoadQuery::RowIter` directly")]
     pub type LoadIter<'conn, 'query, Q, Conn, U, B = crate::connection::DefaultLoadingMode> =
         <Q as load_dsl::LoadQuery<'query, Conn, U, B>>::RowIter<'conn>;
+
+    /// todo
+    pub type Delete<T> = crate::query_builder::DeleteStatement<
+        <T as HasTable>::Table,
+        <T as IntoUpdateTarget>::WhereClause,
+    >;
+
+    pub type InsertInto<T> = crate::query_builder::IncompleteInsertStatement<T>;
+
+    pub type InsertOrIgnoreInto<T> = crate::query_builder::IncompleteInsertOrIgnoreStatement<T>;
+    pub type ReplaceInto<T> = crate::query_builder::IncompleteReplaceStatement<T>;
+
+    pub trait InsertAutoTypeHelper {
+        type Table;
+        type Op;
+    }
+
+    impl<T, Op> InsertAutoTypeHelper for crate::query_builder::IncompleteInsertStatement<T, Op> {
+        type Table = T;
+        type Op = Op;
+    }
+
+    pub type Values<I, U> = crate::query_builder::InsertStatement<
+        <I as InsertAutoTypeHelper>::Table,
+        <U as crate::Insertable<<I as InsertAutoTypeHelper>::Table>>::Values,
+        <I as InsertAutoTypeHelper>::Op,
+    >;
+
+    pub trait UpdateAutoTypeHelper {
+        type Table;
+        type Where;
+    }
+
+    impl<T, W> UpdateAutoTypeHelper for crate::query_builder::UpdateStatement<T, W>
+    where
+        T: crate::QuerySource,
+    {
+        type Table = T;
+
+        type Where = W;
+    }
+
+    pub type Set<U, V> = crate::query_builder::UpdateStatement<
+        <U as UpdateAutoTypeHelper>::Table,
+        <U as UpdateAutoTypeHelper>::Where,
+        <V as crate::AsChangeset>::Changeset,
+    >;
 }
 
 pub mod prelude {

diesel/src/pg/expression/expression_methods.rs

@@ -8,10 +8,10 @@ use super::date_and_time::{AtTimeZone, DateTimeLike};
 use super::operators::*;
 use crate::dsl;
 use crate::expression::grouped::Grouped;
-use crate::expression::operators::{Asc, Desc};
+use crate::expression::operators::{Asc, Concat, Desc, Like, NotLike};
 use crate::expression::{AsExpression, Expression, IntoSql, TypedExpressionType};
 use crate::pg::expression::expression_methods::private::BinaryOrNullableBinary;
-use crate::sql_types::{Array, Binary, Inet, Integer, Jsonb, SqlType, Text, VarChar};
+use crate::sql_types::{Array, Inet, Integer, SqlType, Text, VarChar};
 use crate::EscapeExpressionMethods;
 
 /// PostgreSQL specific methods which are present on all expressions.
@@ -253,7 +253,7 @@ pub trait PgArrayExpressionMethods: Expression + Sized {
     /// #     Ok(())
     /// # }
     /// ```
-    fn contains<T>(self, other: T) -> dsl::ArrayContains<Self, T>
+    fn contains<T>(self, other: T) -> dsl::Contains<Self, T>
     where
         Self::SqlType: SqlType,
         T: AsExpression<Self::SqlType>,
@@ -363,7 +363,7 @@ pub trait PgArrayExpressionMethods: Expression + Sized {
     /// #     Ok(())
     /// # }
     /// ```
-    fn index<T>(self, other: T) -> dsl::ArrayIndex<Self, T>
+    fn index<T>(self, other: T) -> dsl::Index<Self, T>
     where
         Self::SqlType: SqlType,
         T: AsExpression<Integer>,
@@ -409,12 +409,12 @@ pub trait PgArrayExpressionMethods: Expression + Sized {
     /// #     Ok(())
     /// # }
     ///
-    fn concat<T>(self, other: T) -> dsl::ConcatArray<Self, T>
+    fn concat<T>(self, other: T) -> dsl::Concat<Self, T>
     where
         Self::SqlType: SqlType,
         T: AsExpression<Self::SqlType>,
     {
-        Grouped(ConcatArray::new(self, other.as_expression()))
+        Grouped(Concat::new(self, other.as_expression()))
     }
 }
 
@@ -1303,11 +1303,12 @@ pub trait PgJsonbExpressionMethods: Expression + Sized {
     /// #     Ok(())
     /// # }
     /// ```
-    fn concat<T>(self, other: T) -> dsl::ConcatJsonb<Self, T>
+    fn concat<T>(self, other: T) -> dsl::Concat<Self, T>
     where
-        T: AsExpression<Jsonb>,
+        Self::SqlType: SqlType,
+        T: AsExpression<Self::SqlType>,
     {
-        Grouped(ConcatJsonb::new(self, other.as_expression()))
+        Grouped(Concat::new(self, other.as_expression()))
     }
 
     /// Creates a PostgreSQL `?` expression.
@@ -1546,11 +1547,12 @@ pub trait PgJsonbExpressionMethods: Expression + Sized {
     /// #     Ok(())
     /// # }
     /// ```
-    fn contains<T>(self, other: T) -> dsl::ContainsJsonb<Self, T>
+    fn contains<T>(self, other: T) -> dsl::Contains<Self, T>
     where
-        T: AsExpression<Jsonb>,
+        Self::SqlType: SqlType,
+        T: AsExpression<Self::SqlType>,
     {
-        Grouped(ContainsJsonb::new(self, other.as_expression()))
+        Grouped(Contains::new(self, other.as_expression()))
     }
 
     /// Creates a PostgreSQL `<@` expression.
@@ -1611,11 +1613,12 @@ pub trait PgJsonbExpressionMethods: Expression + Sized {
     /// # }
     /// ```
     #[allow(clippy::wrong_self_convention)] // This is named after the sql operator
-    fn is_contained_by<T>(self, other: T) -> dsl::IsContainedByJsonb<Self, T>
+    fn is_contained_by<T>(self, other: T) -> dsl::IsContainedBy<Self, T>
     where
-        T: AsExpression<Jsonb>,
+        Self::SqlType: SqlType,
+        T: AsExpression<Self::SqlType>,
     {
-        Grouped(IsContainedByJsonb::new(self, other.as_expression()))
+        Grouped(IsContainedBy::new(self, other.as_expression()))
     }
 
     /// Creates a PostgreSQL `-` expression.
@@ -2277,12 +2280,12 @@ pub trait PgBinaryExpressionMethods: Expression + Sized {
     /// assert_eq!(Ok(expected_names), names);
     /// # }
     /// ```
-    fn concat<T>(self, other: T) -> dsl::ConcatBinary<Self, T>
+    fn concat<T>(self, other: T) -> dsl::Concat<Self, T>
     where
         Self::SqlType: SqlType,
-        T: AsExpression<Binary>,
+        T: AsExpression<Self::SqlType>,
     {
-        Grouped(ConcatBinary::new(self, other.as_expression()))
+        Grouped(Concat::new(self, other.as_expression()))
     }
 
     /// Creates a PostgreSQL binary `LIKE` expression.
@@ -2327,12 +2330,12 @@ pub trait PgBinaryExpressionMethods: Expression + Sized {
     /// assert_eq!(Ok(vec![b"Sean".to_vec()]), starts_with_s);
     /// # }
     /// ```
-    fn like<T>(self, other: T) -> dsl::LikeBinary<Self, T>
+    fn like<T>(self, other: T) -> dsl::Like<Self, T>
     where
         Self::SqlType: SqlType,
-        T: AsExpression<Binary>,
+        T: AsExpression<Self::SqlType>,
     {
-        Grouped(LikeBinary::new(self, other.as_expression()))
+        Grouped(Like::new(self, other.as_expression()))
     }
 
     /// Creates a PostgreSQL binary `LIKE` expression.
@@ -2377,12 +2380,12 @@ pub trait PgBinaryExpressionMethods: Expression + Sized {
     /// assert_eq!(Ok(vec![b"Tess".to_vec()]), starts_with_s);
     /// # }
     /// ```
-    fn not_like<T>(self, other: T) -> dsl::NotLikeBinary<Self, T>
+    fn not_like<T>(self, other: T) -> dsl::NotLike<Self, T>
     where
         Self::SqlType: SqlType,
-        T: AsExpression<Binary>,
+        T: AsExpression<Self::SqlType>,
     {
-        Grouped(NotLikeBinary::new(self, other.as_expression()))
+        Grouped(NotLike::new(self, other.as_expression()))
     }
 }
 
@@ -2394,7 +2397,7 @@ where
 {
 }
 
-mod private {
+pub(in crate::pg) mod private {
     use crate::sql_types::{
         Array, Binary, Cidr, Inet, Integer, Json, Jsonb, Nullable, Range, SqlType, Text,
     };