Merge remote-tracking branch 'upstream/master' into faillible_queryable_stillgeneric

Author: Ten0

.github/ISSUE_TEMPLATE.md .github/ISSUE_TEMPLATE/bug_report.md.github/ISSUE_TEMPLATE.md renamed to .github/ISSUE_TEMPLATE/bug_report.md

@@ -1,5 +1,14 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
 <!--
-If you want to report a bug, we added some points below you can fill out. If you want to request a feature, feel free to remove all the irrelevant text. In addition to this [issue tracker](https://github.com/diesel-rs/diesel/issues), you can also talk to Diesel maintainers and users on [Gitter](https://gitter.im/diesel-rs/diesel).
+If you want to report a bug, we added some points below which help us track down the problem faster.
 -->
 
 ## Setup
@@ -33,16 +42,22 @@ If you want to report a bug, we added some points below you can fill out. If you
 ### Steps to reproduce
 
 <!--
-Please include as much of your codebase as needed to reproduce the error.  If the relevant files are large, please consider linking to a public repository or a [Gist](https://gist.github.com/).
+Please include as much of your codebase as needed to reproduce the error.  If the relevant files are large, please consider linking to a public repository or a [Gist](https://gist.github.com/). This includes normally the following parts:
 
-Please post as much of your database schema as necessary. If you are using `infer_schema!`, you can use `diesel print-schema` and post the relevant parts from that.
+* The exact code where your hit the problem
+* Relevant parts your schema, so any `table!` macro calls required for the
+* Any other type definitions involved in the code, which produces your problem
 -->
 
 ## Checklist
 
-- [ ] I have already looked over the [issue tracker](https://github.com/diesel-rs/diesel/issues) for similar issues.
+- [ ] I have already looked over the [issue tracker](https://github.com/diesel-rs/diesel/issues)  and the [disussion forum](https://github.com/diesel-rs/diesel/discussions)  for similar possible closed issues.
+<!--
+If you are unsure if your issue is a duplicate of an existing issue please link the issue in question here
+--> 
 - [ ] This issue can be reproduced on Rust's stable channel. (Your issue will be
   closed if this is not the case)
+- [ ] This issue can be reproduced without requiring a third party crate
 
 <!--
 Thank you for your submission!  You're helping make Diesel more robust 🎉

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,14 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Compiler error while compiling diesel
+    url: https://github.com/diesel-rs/diesel/issues?q=is%3Aissue+ld+returned+1+exit+status+
+    about: Failed to compile diesel? Have a look at existing issues. You've likely miss some required dependency.
+  - name: Simple Questions
+    url: https://gitter.im/diesel-rs/diesel
+    about: If you have a simple question please use our gitter channel.
+  - name: Complex Questions
+    url: https://github.com/diesel-rs/diesel/discussions/categories/q-a
+    about: Do you have a larger question? Ask in our forum.
+  - name: Feature Requests
+    url: https://github.com/diesel-rs/diesel/discussions/categories/ideas
+    about: If you want to suggest a new feature please create a new topic in our discussions forum

CONTRIBUTING.md

@@ -36,17 +36,19 @@ Thank you! We'll try to respond as quickly as possible.
 
 ## Submitting feature requests
 
-If you can't find an issue (open or closed) describing your idea on our [issue
-tracker], open an issue. Adding answers to the following
-questions in your description is +1:
+Diesel's issue tracker is meant to represent our current roadmap. An open issue represents either a bug, or a new feature that a member of the Diesel team is actively working on.
 
-- What do you want to do, and how do you expect Diesel to support you with that?
-- How might this be added to Diesel?
-- What are possible alternatives?
-- Are there any disadvantages?
+This means that you should not submit a feature request to our issue tracker, unless you were asked to do so by a member of the Diesel team. Feature requests should instead be posted in
+our [discussion forum](https://github.com/diesel-rs/diesel/discussions/categories/ideas).
 
-Thank you! We'll try to respond as quickly as possible.
+If you can't find thread describing your idea on our forum, create a new one. Adding answers to the following questions in your description is +1:
+
+-   What do you want to do, and how do you expect Diesel to support you with that?
+-   How might this be added to Diesel?
+-   What are possible alternatives?
+-   Are there any disadvantages?
 
+Thank you! We'll try to respond as quickly as possible.
 
 ## Contribute code to Diesel
 

diesel/src/expression/count.rs

@@ -3,7 +3,7 @@ use super::{Expression, ValidGrouping};
 use crate::backend::Backend;
 use crate::query_builder::*;
 use crate::result::QueryResult;
-use crate::sql_types::{BigInt, DieselNumericOps, Nullable, SingleValue, SqlType};
+use crate::sql_types::{BigInt, DieselNumericOps, SingleValue, SqlType};
 
 sql_function! {
     /// Creates a SQL `COUNT` expression
@@ -25,7 +25,7 @@ sql_function! {
     /// # }
     /// ```
     #[aggregate]
-    fn count<T: SqlType + SingleValue>(expr: Nullable<T>) -> BigInt;
+    fn count<T: SqlType + SingleValue>(expr: T) -> BigInt;
 }
 
 /// Creates a SQL `COUNT(*)` expression

diesel/src/expression/functions/aggregate_folding.rs

@@ -1,5 +1,5 @@
 use crate::expression::functions::sql_function;
-use crate::sql_types::{Foldable, Nullable};
+use crate::sql_types::Foldable;
 
 sql_function! {
     /// Represents a SQL `SUM` function. This function can only take types which are
@@ -18,7 +18,7 @@ sql_function! {
     /// # }
     /// ```
     #[aggregate]
-    fn sum<ST: Foldable>(expr: Nullable<ST>) -> ST::Sum;
+    fn sum<ST: Foldable>(expr: ST) -> ST::Sum;
 }
 
 sql_function! {
@@ -64,5 +64,5 @@ sql_function! {
     /// #     Ok(())
     /// # }
     #[aggregate]
-    fn avg<ST: Foldable>(expr: Nullable<ST>) -> ST::Avg;
+    fn avg<ST: Foldable>(expr: ST) -> ST::Avg;
 }

diesel/src/expression/functions/aggregate_ordering.rs

@@ -1,16 +1,16 @@
 use crate::expression::functions::sql_function;
-use crate::sql_types::{IntoNullable, Nullable, SingleValue, SqlOrd, SqlType};
+use crate::sql_types::{IntoNullable, SingleValue, SqlOrd, SqlType};
 
 pub trait SqlOrdAggregate: SingleValue {
     type Ret: SqlType + SingleValue;
 }
 
-impl<ST> SqlOrdAggregate for ST
+impl<T> SqlOrdAggregate for T
 where
-    ST: SqlOrd + SingleValue + IntoNullable,
-    ST::Nullable: SingleValue,
+    T: SqlOrd + IntoNullable + SingleValue,
+    T::Nullable: SqlType + SingleValue,
 {
-    type Ret = <Self as IntoNullable>::Nullable;
+    type Ret = T::Nullable;
 }
 
 sql_function! {
@@ -29,7 +29,7 @@ sql_function! {
     /// assert_eq!(Ok(Some(8)), animals.select(max(legs)).first(&connection));
     /// # }
     #[aggregate]
-    fn max<ST: SqlOrdAggregate>(expr: Nullable<ST>) -> ST::Ret;
+    fn max<ST: SqlOrdAggregate>(expr: ST) -> ST::Ret;
 }
 
 sql_function! {
@@ -48,5 +48,5 @@ sql_function! {
     /// assert_eq!(Ok(Some(4)), animals.select(min(legs)).first(&connection));
     /// # }
     #[aggregate]
-    fn min<ST: SqlOrdAggregate>(expr: Nullable<ST>) -> ST::Ret;
+    fn min<ST: SqlOrdAggregate>(expr: ST) -> ST::Ret;
 }

diesel/src/expression/functions/date_and_time.rs

@@ -1,8 +1,7 @@
 use crate::backend::Backend;
+use crate::expression::coerce::Coerce;
 use crate::expression::functions::sql_function;
-#[cfg(feature = "postgres")]
-use crate::expression::{coerce::Coerce, AsExpression};
-use crate::expression::{Expression, ValidGrouping};
+use crate::expression::{AsExpression, Expression, ValidGrouping};
 use crate::query_builder::*;
 use crate::result::QueryResult;
 use crate::sql_types::*;
@@ -47,6 +46,14 @@ sql_function! {
     fn date(expr: Timestamp) -> Date;
 }
 
+impl AsExpression<Nullable<Timestamp>> for now {
+    type Expression = Coerce<now, Nullable<Timestamp>>;
+
+    fn as_expression(self) -> Self::Expression {
+        Coerce::new(self)
+    }
+}
+
 #[cfg(feature = "postgres")]
 impl AsExpression<Timestamptz> for now {
     type Expression = Coerce<now, Timestamptz>;
@@ -85,3 +92,11 @@ impl_selectable_expression!(today);
 
 operator_allowed!(today, Add, add);
 operator_allowed!(today, Sub, sub);
+
+impl AsExpression<Nullable<Date>> for today {
+    type Expression = Coerce<today, Nullable<Date>>;
+
+    fn as_expression(self) -> Self::Expression {
+        Coerce::new(self)
+    }
+}

diesel/src/expression/functions/helper_types.rs

@@ -1,12 +1,11 @@
 #![allow(non_camel_case_types)]
 
-use crate::dsl::{AsExprOf, SqlTypeOf};
+use crate::dsl::SqlTypeOf;
 use crate::expression::grouped::Grouped;
 use crate::expression::operators;
-use crate::sql_types::{Bool, Nullable};
 
 /// The return type of [`not(expr)`](../dsl/fn.not.html)
-pub type not<Expr> = operators::Not<Grouped<AsExprOf<Expr, Nullable<Bool>>>>;
+pub type not<Expr> = operators::Not<Grouped<Expr>>;
 
 /// The return type of [`max(expr)`](../dsl/fn.max.html)
 pub type max<Expr> = super::aggregate_ordering::max::HelperType<SqlTypeOf<Expr>, Expr>;

diesel/src/expression/helper_types.rs

@@ -89,11 +89,12 @@ pub type Nullable<Expr> = super::nullable::Nullable<Expr>;
 
 /// The return type of
 /// [`lhs.and(rhs)`](../expression_methods/trait.BoolExpressionMethods.html#method.and)
-pub type And<Lhs, Rhs> = Grouped<super::operators::And<Nullable<Lhs>, AsExpr<Rhs, Nullable<Lhs>>>>;
+pub type And<Lhs, Rhs, ST = sql_types::Bool> =
+    Grouped<super::operators::And<Lhs, AsExprOf<Rhs, ST>>>;
 
 /// The return type of
 /// [`lhs.or(rhs)`](../expression_methods/trait.BoolExpressionMethods.html#method.or)
-pub type Or<Lhs, Rhs> = Grouped<super::operators::Or<Lhs, AsExpr<Rhs, Nullable<Lhs>>>>;
+pub type Or<Lhs, Rhs, ST = sql_types::Bool> = Grouped<super::operators::Or<Lhs, AsExprOf<Rhs, ST>>>;
 
 /// The return type of
 /// [`lhs.escape('x')`](../expression_methods/trait.EscapeExpressionMethods.html#method.escape)

diesel/src/expression/mod.rs

@@ -82,7 +82,7 @@ pub use self::sql_literal::{SqlLiteral, UncheckedBind};
 
 use crate::backend::Backend;
 use crate::dsl::AsExprOf;
-use crate::sql_types::{HasSqlType, IntoNotNullable, SingleValue, SqlType};
+use crate::sql_types::{HasSqlType, SingleValue, SqlType};
 
 /// Represents a typed fragment of SQL.
 ///
@@ -208,101 +208,14 @@ pub use diesel_derives::AsExpression;
 
 impl<T, ST> AsExpression<ST> for T
 where
-    ST: SqlType + IntoNotNullable + TypedExpressionType,
-    ST::NotNullable: SingleValue,
-    self::as_expression_impl::ExpressionImplHelper<T, ST::IsNull, <T::SqlType as SqlType>::IsNull>:
-        self::as_expression_impl::AsExpressionHelper<ST>,
-    T: Expression,
-    T::SqlType: SqlType,
+    T: Expression<SqlType = ST>,
+    ST: SqlType + TypedExpressionType,
 {
-    type Expression = <self::as_expression_impl::ExpressionImplHelper<
-        T,
-        ST::IsNull,
-        <T::SqlType as SqlType>::IsNull,
-    > as self::as_expression_impl::AsExpressionHelper<ST>>::Expression;
-
-    fn as_expression(self) -> Self::Expression {
-        use self::as_expression_impl::AsExpressionHelper;
-
-        let t = self::as_expression_impl::ExpressionImplHelper::<
-            _,
-            ST::IsNull,
-            <T::SqlType as SqlType>::IsNull,
-        >(self, std::marker::PhantomData);
-        t.as_expression()
-    }
-}
-
-mod as_expression_impl {
-    use super::*;
-    use crate::sql_types::is_nullable;
+    type Expression = Self;
 
-    #[allow(missing_debug_implementations)]
-    pub struct ExpressionImplHelper<T, IsNullExpr, IsNullAsExpr>(
-        pub T,
-        pub std::marker::PhantomData<(IsNullExpr, IsNullAsExpr)>,
-    );
-
-    // We could use `AsExpression` here instead of defining a new trait in theory
-    // in practice we hit https://github.com/rust-lang/rust/issues/77446 then
-    // when defining a custom type in a third party crate
-    pub trait AsExpressionHelper<ST: TypedExpressionType> {
-        type Expression: Expression<SqlType = ST>;
-
-        fn as_expression(self) -> Self::Expression;
+    fn as_expression(self) -> Self {
+        self
     }
-
-    // This impl is for accepting a not nullable expression in a position where
-    // a not nullable expression is expected
-    impl<T, ST> AsExpressionHelper<ST>
-        for ExpressionImplHelper<T, is_nullable::NotNull, is_nullable::NotNull>
-    where
-        ST: SqlType<IsNull = is_nullable::NotNull> + TypedExpressionType,
-        T: Expression<SqlType = ST>,
-    {
-        type Expression = T;
-
-        fn as_expression(self) -> Self::Expression {
-            self.0
-        }
-    }
-
-    // This impl is for accepting a not nullable expression in a position where
-    // a nullable expression is expected
-    impl<T, ST> AsExpressionHelper<ST>
-        for ExpressionImplHelper<T, is_nullable::IsNullable, is_nullable::NotNull>
-    where
-        ST: SqlType<IsNull = is_nullable::IsNullable> + IntoNotNullable + TypedExpressionType,
-        ST::NotNullable: TypedExpressionType + SqlType,
-        T: Expression<SqlType = ST::NotNullable>,
-        super::nullable::Nullable<T>: Expression<SqlType = ST>,
-    {
-        type Expression = super::nullable::Nullable<T>;
-
-        fn as_expression(self) -> Self::Expression {
-            super::nullable::Nullable::new(self.0)
-        }
-    }
-
-    // This impl is for accepting a nullable expression in a position where
-    // a nullable expression is expected
-    impl<T, ST> AsExpressionHelper<ST>
-        for ExpressionImplHelper<T, is_nullable::IsNullable, is_nullable::IsNullable>
-    where
-        ST: SqlType<IsNull = is_nullable::IsNullable> + TypedExpressionType,
-        T: Expression<SqlType = ST>,
-    {
-        type Expression = T;
-
-        fn as_expression(self) -> Self::Expression {
-            self.0
-        }
-    }
-
-    // impl<T, ST> AsExpressionHelper<ST> for
-    //     ExpressionImplHelper<T, is_nullable::NotNull, is_nullable::IsNullable>
-    // is missing because we don't want to accept a nullable expression in possition where
-    // where a not nullable expression is expected
 }
 
 /// Converts a type to its representation for use in Diesel's query builder.