Implement support for "FOR UPDATE" modifiers

Format

Add test

Add compile test

Fix compile fail test

Add a second compile test

Review changes

Fix compile tests

Remove error case

Fix tests

Implement for no key update

Add test to check insert is blocked by for update

Update for_update_clause.rs

Update select.rs

Implement "FOR SHARE" clause

Fix rename

Update mysql impls

Author: Diggsey

diesel/src/expression/array_comparison.rs

@@ -129,7 +129,7 @@ pub trait MaybeEmpty {
     fn is_empty(&self) -> bool;
 }
 
-impl<ST, S, F, W, O, L, Of, G, FU> AsInExpression<ST> for SelectStatement<S, F, W, O, L, Of, G, FU>
+impl<ST, S, F, W, O, L, Of, G, LC> AsInExpression<ST> for SelectStatement<S, F, W, O, L, Of, G, LC>
 where
     Subselect<Self, ST>: Expression<SqlType = ST>,
     Self: SelectQuery<SqlType = ST>,

diesel/src/lib.rs

@@ -225,6 +225,21 @@ pub mod helper_types {
     /// Represents the return type of `.for_update()`
     pub type ForUpdate<Source> = <Source as ForUpdateDsl>::Output;
 
+    /// Represents the return type of `.for_no_key_update()`
+    pub type ForNoKeyUpdate<Source> = <Source as ForNoKeyUpdateDsl>::Output;
+
+    /// Represents the return type of `.for_share()`
+    pub type ForShare<Source> = <Source as ForShareDsl>::Output;
+
+    /// Represents the return type of `.for_key_share()`
+    pub type ForKeyShare<Source> = <Source as ForKeyShareDsl>::Output;
+
+    /// Represents the return type of `.skip_locked()`
+    pub type SkipLocked<Source> = <Source as SkipLockedDsl>::Output;
+
+    /// Represents the return type of `.no_wait()`
+    pub type NoWait<Source> = <Source as NoWaitDsl>::Output;
+
     /// Represents the return type of `.find(pk)`
     pub type Find<Source, PK> = <Source as FindDsl<PK>>::Output;
 

diesel/src/mysql/query_builder/query_fragment_impls.rs

@@ -1,11 +1,38 @@
 use mysql::Mysql;
 use query_builder::{AstPass, QueryFragment};
-use query_builder::for_update_clause::ForUpdateClause;
+use query_builder::locking_clause::{ForUpdate, ForShare, NoModifier, NoWait, SkipLocked};
 use result::QueryResult;
 
-impl QueryFragment<Mysql> for ForUpdateClause {
+impl QueryFragment<Mysql> for ForUpdate {
     fn walk_ast(&self, mut out: AstPass<Mysql>) -> QueryResult<()> {
         out.push_sql(" FOR UPDATE");
         Ok(())
     }
 }
+
+impl QueryFragment<Mysql> for ForShare {
+    fn walk_ast(&self, mut out: AstPass<Mysql>) -> QueryResult<()> {
+        out.push_sql(" FOR SHARE");
+        Ok(())
+    }
+}
+
+impl QueryFragment<Mysql> for NoModifier {
+    fn walk_ast(&self, _out: AstPass<Mysql>) -> QueryResult<()> {
+        Ok(())
+    }
+}
+
+impl QueryFragment<Mysql> for SkipLocked {
+    fn walk_ast(&self, mut out: AstPass<Mysql>) -> QueryResult<()> {
+        out.push_sql(" SKIP LOCKED");
+        Ok(())
+    }
+}
+
+impl QueryFragment<Mysql> for NoWait {
+    fn walk_ast(&self, mut out: AstPass<Mysql>) -> QueryResult<()> {
+        out.push_sql(" NOWAIT");
+        Ok(())
+    }
+}

diesel/src/pg/query_builder/distinct_on.rs

@@ -39,7 +39,7 @@ where
             self.limit,
             self.offset,
             self.group_by,
-            self.for_update,
+            self.locking,
         )
     }
 }

diesel/src/pg/query_builder/query_fragment_impls.rs

@@ -1,11 +1,52 @@
 use pg::Pg;
 use query_builder::{AstPass, QueryFragment};
-use query_builder::for_update_clause::ForUpdateClause;
+use query_builder::locking_clause::{ForUpdate, ForKeyShare, ForNoKeyUpdate, ForShare, NoModifier, NoWait, SkipLocked};
 use result::QueryResult;
 
-impl QueryFragment<Pg> for ForUpdateClause {
+impl QueryFragment<Pg> for ForUpdate {
     fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
         out.push_sql(" FOR UPDATE");
         Ok(())
     }
 }
+
+impl QueryFragment<Pg> for ForNoKeyUpdate {
+    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+        out.push_sql(" FOR NO KEY UPDATE");
+        Ok(())
+    }
+}
+
+impl QueryFragment<Pg> for ForShare {
+    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+        out.push_sql(" FOR SHARE");
+        Ok(())
+    }
+}
+
+impl QueryFragment<Pg> for ForKeyShare {
+    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+        out.push_sql(" FOR KEY SHARE");
+        Ok(())
+    }
+}
+
+impl QueryFragment<Pg> for NoModifier {
+    fn walk_ast(&self, _out: AstPass<Pg>) -> QueryResult<()> {
+        Ok(())
+    }
+}
+
+impl QueryFragment<Pg> for SkipLocked {
+    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+        out.push_sql(" SKIP LOCKED");
+        Ok(())
+    }
+}
+
+impl QueryFragment<Pg> for NoWait {
+    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+        out.push_sql(" NOWAIT");
+        Ok(())
+    }
+}

diesel/src/query_builder/for_update_clause.rs

@@ -0,0 +1,56 @@
+use backend::Backend;
+use query_builder::{AstPass, QueryFragment};
+use result::QueryResult;
+
+#[derive(Debug, Clone, Copy, QueryId)]
+pub struct NoLockingClause;
+
+impl<DB: Backend> QueryFragment<DB> for NoLockingClause {
+    fn walk_ast(&self, _: AstPass<DB>) -> QueryResult<()> {
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, Copy, QueryId)]
+pub struct LockingClause<LockMode = ForUpdate, Modifier = NoModifier> {
+    pub(crate) lock_mode: LockMode,
+    modifier: Modifier,
+}
+
+impl<LockMode, Modifier> LockingClause<LockMode, Modifier> {
+    pub(crate) fn new(lock_mode: LockMode, modifier: Modifier) -> Self {
+        LockingClause { lock_mode, modifier }
+    }
+}
+
+impl<DB: Backend, L: QueryFragment<DB>, M: QueryFragment<DB>> QueryFragment<DB> for LockingClause<L, M> {
+    fn walk_ast(&self, mut out: AstPass<DB>) -> QueryResult<()> {
+        self.lock_mode.walk_ast(out.reborrow())?;
+        self.modifier.walk_ast(out.reborrow())
+    }
+}
+
+/// LockMode parameters
+/// All the different types of row locks that can be acquired.
+#[derive(Debug, Clone, Copy, QueryId)]
+pub struct ForUpdate;
+
+#[derive(Debug, Clone, Copy, QueryId)]
+pub struct ForNoKeyUpdate;
+
+#[derive(Debug, Clone, Copy, QueryId)]
+pub struct ForShare;
+
+#[derive(Debug, Clone, Copy, QueryId)]
+pub struct ForKeyShare;
+
+/// Modifiers
+/// To be used in conjunction with a lock mode.
+#[derive(Debug, Clone, Copy, QueryId)]
+pub struct NoModifier;
+
+#[derive(Debug, Clone, Copy, QueryId)]
+pub struct SkipLocked;
+
+#[derive(Debug, Clone, Copy, QueryId)]
+pub struct NoWait;

diesel/src/query_builder/locking_clause.rs

@@ -18,7 +18,7 @@ pub mod functions;
 #[doc(hidden)]
 pub mod nodes;
 mod distinct_clause;
-pub(crate) mod for_update_clause;
+pub(crate) mod locking_clause;
 mod group_by_clause;
 mod limit_clause;
 mod offset_clause;