Merge pull request diesel-rs#178 from robertmaloney/rm/timestamp-helpers

Add helpers for managing `updated_at TIMESTAMP` columns

Author: sgrif

CHANGELOG.md

@@ -3,6 +3,15 @@ All user visible changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/), as described
 for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/text/1105-api-evolution.md)
 
+## Unreleased
+
+### Added
+
+* Added helper function `diesel_manage_updated_at('TABLE_NAME')` to postgres
+  upon database setup. This function sets up a trigger on the specified table
+  that automatically updates the `updated_at` column to the `current_timestamp`
+  for each affected row in `UPDATE` statements.
+
 ## [0.5.1] 2016-02-11
 
 * Diesel CLI no longer has a hard dependency on SQLite and PostgreSQL. It

diesel/src/connection/mod.rs

@@ -93,4 +93,6 @@ pub trait Connection: SimpleConnection + Sized {
     #[doc(hidden)] fn rollback_transaction(&self) -> QueryResult<()>;
     #[doc(hidden)] fn commit_transaction(&self) -> QueryResult<()>;
     #[doc(hidden)] fn get_transaction_depth(&self) -> i32;
+
+    #[doc(hidden)] fn setup_helper_functions(&self);
 }

diesel/src/migrations/mod.rs

@@ -103,7 +103,7 @@ pub fn run_pending_migrations_in_directory<Conn>(conn: &Conn, migrations_dir: &P
     -> Result<(), RunMigrationsError> where
         Conn: MigrationConnection,
 {
-    try!(create_schema_migrations_table_if_needed(conn));
+    try!(setup_database(conn));
     let already_run = try!(conn.previously_run_migration_versions());
     let all_migrations = try!(migrations_in_directory(migrations_dir));
     let pending_migrations = all_migrations.into_iter().filter(|m| {
@@ -120,7 +120,7 @@ pub fn run_pending_migrations_in_directory<Conn>(conn: &Conn, migrations_dir: &P
 pub fn revert_latest_migration<Conn>(conn: &Conn) -> Result<String, RunMigrationsError> where
     Conn: MigrationConnection,
 {
-    try!(create_schema_migrations_table_if_needed(conn));
+    try!(setup_database(conn));
     let latest_migration_version = try!(conn.latest_run_migration_version());
     revert_migration_with_version(conn, &latest_migration_version, &mut stdout())
         .map(|_| latest_migration_version)
@@ -158,7 +158,12 @@ fn migration_with_version(ver: &str) -> Result<Box<Migration>, MigrationError> {
 }
 
 #[doc(hidden)]
-pub fn create_schema_migrations_table_if_needed<Conn: Connection>(conn: &Conn) -> QueryResult<usize> {
+pub fn setup_database<Conn: Connection>(conn: &Conn) -> QueryResult<usize> {
+    conn.setup_helper_functions();
+    create_schema_migrations_table_if_needed(conn)
+}
+
+fn create_schema_migrations_table_if_needed<Conn: Connection>(conn: &Conn) -> QueryResult<usize> {
     conn.silence_notices(|| {
         conn.execute("CREATE TABLE IF NOT EXISTS __diesel_schema_migrations (
             version VARCHAR PRIMARY KEY NOT NULL,

diesel/src/pg/connection/mod.rs

@@ -114,6 +114,12 @@ impl Connection for PgConnection {
     fn get_transaction_depth(&self) -> i32 {
         self.transaction_depth.get()
     }
+
+    fn setup_helper_functions(&self) {
+        self.batch_execute(
+            include_str!("setup/timestamp_helpers.sql")
+        ).expect("Error creating timestamp helper functions for Pg");
+    }
 }
 
 impl PgConnection {

diesel/src/pg/connection/setup/timestamp_helpers.sql

@@ -0,0 +1,18 @@
+CREATE OR REPLACE FUNCTION diesel_set_updated_at() RETURNS trigger AS $$
+BEGIN
+    IF (
+        NEW IS DISTINCT FROM OLD AND
+        NEW.updated_at IS NOT DISTINCT FROM OLD.updated_at
+    ) THEN
+        NEW.updated_at := current_timestamp;
+    END IF;
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION diesel_manage_updated_at(_tbl regclass) RETURNS VOID AS $$
+BEGIN
+    EXECUTE format('CREATE TRIGGER set_updated_at BEFORE UPDATE ON %s
+                    FOR EACH ROW EXECUTE PROCEDURE diesel_set_updated_at()', _tbl);
+END;
+$$ LANGUAGE plpgsql;

diesel/src/sqlite/connection/mod.rs

@@ -107,6 +107,10 @@ impl Connection for SqliteConnection {
     fn get_transaction_depth(&self) -> i32 {
         self.transaction_depth.get()
     }
+
+    fn setup_helper_functions(&self) {
+        // this will be implemented at least when timestamps are supported in SQLite
+    }
 }
 
 impl SqliteConnection {

diesel_cli/src/database.rs

@@ -128,7 +128,7 @@ fn create_schema_table_and_run_migrations_if_needed(database_url: &String)
     -> DatabaseResult<()>
 {
     if !schema_table_exists(database_url).map_err(handle_error).unwrap() {
-        try!(call_with_conn!(database_url, migrations::create_schema_migrations_table_if_needed));
+        try!(call_with_conn!(database_url, migrations::setup_database));
         call_with_conn!(database_url, migrations::run_pending_migrations).unwrap_or_else(handle_error);
     };
     Ok(())

diesel_tests/tests/connection.rs

@@ -0,0 +1,49 @@
+use schema::connection_without_transaction;
+use diesel::*;
+use diesel::expression::dsl::sql;
+
+table! {
+    auto_time {
+        id -> Integer,
+        n -> Integer,
+        updated_at -> Timestamp,
+    }
+}
+
+#[test]
+#[cfg(feature = "postgres")]
+fn managing_updated_at_for_table() {
+    use self::auto_time::columns::*;
+    use self::auto_time::table as auto_time;
+    use diesel::pg::types::date_and_time::PgTimestamp;
+
+    // transactions have frozen time, so we can't use them
+    let connection = connection_without_transaction();
+    connection.execute("CREATE TABLE auto_time (
+        id SERIAL PRIMARY KEY,
+        n INTEGER,
+        updated_at TIMESTAMP
+    );").unwrap();
+    connection.execute("SELECT diesel_manage_updated_at('auto_time');").unwrap();
+
+    connection.execute("INSERT INTO auto_time (n) VALUES (2), (1), (5);").unwrap();
+    let result = connection.query_one::<_, i64>(
+        select(sql("COUNT(*) FROM auto_time WHERE updated_at IS NULL"))
+    );
+    assert_eq!(Ok(3), result);
+
+    connection.execute("UPDATE auto_time SET n = n + 1 WHERE true;").unwrap();
+    let result = connection.query_one::<_, i64>(
+        select(sql("COUNT(*) FROM auto_time WHERE updated_at IS NULL"))
+    );
+    assert_eq!(Ok(0), result);
+
+    let query = auto_time.find(2).select(updated_at);
+    let old_time: PgTimestamp = query.first(&connection).unwrap();
+    update(auto_time.find(2)).set(n.eq(0)).execute(&connection).unwrap();
+    let new_time: PgTimestamp = query.first(&connection).unwrap();
+    assert!(old_time < new_time);
+
+    // clean up because we aren't in a transaction
+    connection.execute("DROP TABLE auto_time;").unwrap();
+}

diesel_tests/tests/lib.rs

@@ -12,6 +12,7 @@ include!(concat!(env!("OUT_DIR"), "/lib.rs"));
 
 mod associations;
 mod expressions;
+mod connection;
 mod filter;
 mod filter_operators;
 mod find;