Merge pull request diesel-rs#2502 from TaKO8Ki/current-date

Add support for CURRENT_DATE

Author: weiznich

diesel/src/expression/functions/date_and_time.rs

@@ -71,3 +71,32 @@ impl AsExpression<Nullable<Timestamptz>> for now {
         Coerce::new(self)
     }
 }
+
+/// Represents the SQL `CURRENT_DATE` constant.
+#[allow(non_camel_case_types)]
+#[derive(Debug, Copy, Clone, QueryId, ValidGrouping)]
+pub struct today;
+
+impl Expression for today {
+    type SqlType = Date;
+}
+
+impl<DB: Backend> QueryFragment<DB> for today {
+    fn walk_ast(&self, mut out: AstPass<DB>) -> QueryResult<()> {
+        out.push_sql("CURRENT_DATE");
+        Ok(())
+    }
+}
+
+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_tests/tests/expressions/date_and_time.rs

@@ -29,6 +29,13 @@ table! {
     }
 }
 
+table! {
+    has_date {
+        id -> Integer,
+        date -> Date,
+    }
+}
+
 #[cfg(feature = "postgres")]
 table! {
     nullable_date_and_time {
@@ -134,6 +141,120 @@ fn now_can_be_used_as_nullable() {
     assert_eq!(Ok(Some(true)), result);
 }
 
+#[test]
+fn today_can_be_used_as_nullable() {
+    use diesel::sql_types::Date;
+
+    let nullable_date = sql::<Nullable<Date>>("CURRENT_DATE");
+    let result = select(nullable_date.eq(today)).get_result(&connection());
+
+    assert_eq!(Ok(Some(true)), result);
+}
+
+#[test]
+#[cfg(feature = "postgres")]
+fn today_executes_sql_function_current_date() {
+    use self::has_date::dsl::*;
+
+    let connection = connection();
+    setup_test_table(&connection);
+    connection
+        .execute(
+            "INSERT INTO has_date (date) VALUES
+                (current_date - '1 day'::interval), (current_date + '1 day'::interval);",
+        )
+        .unwrap();
+
+    let before_today = has_date
+        .select(id)
+        .filter(date.lt(today))
+        .load::<i32>(&connection);
+    let after_today = has_date
+        .select(id)
+        .filter(date.gt(today))
+        .load::<i32>(&connection);
+    assert_eq!(Ok(vec![1]), before_today);
+    assert_eq!(Ok(vec![2]), after_today);
+}
+
+#[test]
+#[cfg(feature = "sqlite")]
+fn today_executes_sql_function_current_date() {
+    use self::has_date::dsl::*;
+
+    let connection = connection();
+    setup_test_table(&connection);
+    connection
+        .execute(
+            "INSERT INTO has_date (date) VALUES
+                (DATE('now', '-1 day')), (DATE('now', '+1 day'));",
+        )
+        .unwrap();
+
+    let before_today = has_date
+        .select(id)
+        .filter(date.lt(today))
+        .load::<i32>(&connection);
+    let after_today = has_date
+        .select(id)
+        .filter(date.gt(today))
+        .load::<i32>(&connection);
+    assert_eq!(Ok(vec![1]), before_today);
+    assert_eq!(Ok(vec![2]), after_today);
+}
+
+#[test]
+#[cfg(feature = "mysql")]
+fn today_executes_sql_function_current_date() {
+    use self::has_date::dsl::*;
+
+    let connection = connection();
+    setup_test_table(&connection);
+    connection
+        .execute(
+            "INSERT INTO has_date (date) VALUES
+                (current_date - interval 1 day), (current_date + interval 1 day);",
+        )
+        .unwrap();
+
+    let before_today = has_date
+        .select(id)
+        .filter(date.lt(today))
+        .load::<i32>(&connection);
+    let after_today = has_date
+        .select(id)
+        .filter(date.gt(today))
+        .load::<i32>(&connection);
+    assert_eq!(Ok(vec![1]), before_today);
+    assert_eq!(Ok(vec![2]), after_today);
+}
+
+#[test]
+#[cfg(feature = "mysql")]
+fn now_executes_sql_function_now() {
+    use self::has_timestamps::dsl::*;
+
+    let connection = connection();
+    setup_test_table(&connection);
+    connection
+        .execute(
+            "INSERT INTO has_timestamps (created_at) VALUES
+                       (NOW() - interval 1 day), (NOW() + interval 1 day)",
+        )
+        .unwrap();
+
+    let before_today = has_timestamps
+        .select(id)
+        .filter(created_at.lt(now))
+        .load::<i32>(&connection);
+    let after_today = has_timestamps
+        .select(id)
+        .filter(created_at.gt(now))
+        .load::<i32>(&connection);
+    assert_eq!(Ok(vec![1]), before_today);
+    assert_eq!(Ok(vec![2]), after_today);
+}
+
 #[test]
 #[cfg(feature = "sqlite")]
 fn now_executes_sql_function_now() {
@@ -159,7 +280,6 @@ fn now_executes_sql_function_now() {
     assert_eq!(Ok(vec![1]), before_today);
     assert_eq!(Ok(vec![2]), after_today);
 }
-
 #[test]
 #[cfg(not(feature = "mysql"))] // FIXME: Figure out how to handle tests that modify schema
 fn date_uses_sql_function_date() {
@@ -333,7 +453,7 @@ fn adding_interval_to_nullable_things() {
     assert_eq!(expected_data, actual_data);
 }
 
-#[cfg(not(feature = "mysql"))] // FIXME: Figure out how to handle tests that modify schema
+#[cfg(any(feature = "postgres", feature = "sqlite", feature = "mysql"))]
 fn setup_test_table(conn: &TestConnection) {
     use crate::schema_dsl::*;
 
@@ -374,6 +494,16 @@ fn setup_test_table(conn: &TestConnection) {
     .execute(conn)
     .unwrap();
 
+    create_table(
+        "has_date",
+        (
+            integer("id").primary_key().auto_increment(),
+            date("date").not_null(),
+        ),
+    )
+    .execute(conn)
+    .unwrap();
+
     create_table(
         "nullable_date_and_time",
         (

diesel_tests/tests/schema_dsl/structures.rs

@@ -84,7 +84,7 @@ where
 {
     fn walk_ast(&self, mut out: AstPass<DB>) -> QueryResult<()> {
         out.unsafe_to_cache_prepared();
-        out.push_sql("CREATE TABLE ");
+        out.push_sql("CREATE TABLE IF NOT EXISTS ");
         out.push_identifier(self.name)?;
         out.push_sql(" (");
         self.columns.walk_ast(out.reborrow())?;