Feature/prepared counter statements (#891)

* Adding prepared counter statements

* Adding tests for prepared counters

* Fixing counter prepared tests

phantom-dsl/src/main/scala/com/outworkers/phantom/DefaultImports.scala

@@ -215,13 +215,33 @@ trait DefaultImports extends ImplicitMechanism
       new UpdateClause.Condition(QueryBuilder.Update.increment(col.name, value.toString))
     }
 
+    final def +=(value: PrepareMark): UpdateClause.Prepared[Long] = {
+      increment(value)
+    }
+
     final def increment[T : Numeric](value: T): UpdateClause.Default = +=(value)
 
+    final def increment(value: PrepareMark): UpdateClause.Prepared[Long] = {
+      new UpdateClause.Prepared[Long](
+        QueryBuilder.Update.increment(col.name, value.qb.queryString)
+      )
+    }
+
     final def -=[T : Numeric](value: T): UpdateClause.Default = {
       new UpdateClause.Condition(QueryBuilder.Update.decrement(col.name, value.toString))
     }
 
+    final def -=(value: PrepareMark): UpdateClause.Prepared[Long] = {
+      decrement(value)
+    }
+
     final def decrement[T : Numeric](value: T): UpdateClause.Default = -=(value)
+
+    final def decrement(value: PrepareMark): UpdateClause.Prepared[Long] = {
+      new UpdateClause.Prepared[Long](
+        QueryBuilder.Update.decrement(col.name, value.qb.queryString)
+      )
+    }
   }
 
   /**

phantom-dsl/src/test/scala/com/outworkers/phantom/builder/query/db/specialized/CounterColumnTest.scala

@@ -31,9 +31,9 @@ class CounterColumnTest extends PhantomSuite {
     val sample = gen[CounterRecord]
 
     val chain = for {
-      incr <-  database.counterTableTest.update.where(_.id eqs sample.id).modify(_.count_entries += 0).future()
+      _ <-  database.counterTableTest.update.where(_.id eqs sample.id).modify(_.count_entries += 0).future()
       select <- database.counterTableTest.select.where(_.id eqs sample.id).one
-      incr <-  database.counterTableTest.update.where(_.id eqs sample.id).modify(_.count_entries += 1).future()
+      _ <-  database.counterTableTest.update.where(_.id eqs sample.id).modify(_.count_entries += 1).future()
       select2 <- database.counterTableTest.select.where(_.id eqs sample.id).one
     } yield (select, select2)
 
@@ -44,13 +44,37 @@ class CounterColumnTest extends PhantomSuite {
     }
   }
 
+  it should "+= counter values by 1 using prepared statements" in {
+    val sample = gen[CounterRecord]
+
+    val query = database.counterTableTest
+      .update
+      .where(_.id eqs ?)
+      .modify(_.count_entries += ?)
+      .prepareAsync()
+
+    val chain = for {
+      _ <- database.counterTableTest.update
+        .where(_.id eqs sample.id)
+        .modify(_.count_entries += sample.count)
+        .future()
+      _ <-  query.flatMap(_.bind(1L, sample.id).future())
+      select2 <- database.counterTableTest.select.where(_.id eqs sample.id).one
+    } yield select2
+
+
+    whenReady(chain) { res =>
+      res.value.count shouldEqual sample.count + 1
+    }
+  }
+
   it should "allow selecting a counter" in {
     val sample = gen[CounterRecord]
 
     val chain = for {
-      incr <-  database.counterTableTest.update.where(_.id eqs sample.id).modify(_.count_entries += 500).future()
+      _ <-  database.counterTableTest.update.where(_.id eqs sample.id).modify(_.count_entries += 500).future()
       select <- database.counterTableTest.select.where(_.id eqs sample.id).one
-      incr <-  database.counterTableTest.update.where(_.id eqs sample.id).modify(_.count_entries += 1).future()
+      _ <-  database.counterTableTest.update.where(_.id eqs sample.id).modify(_.count_entries += 1).future()
       select2 <- database.counterTableTest.select(_.count_entries).where(_.id eqs sample.id).one
     } yield (select, select2)
 
@@ -66,9 +90,9 @@ class CounterColumnTest extends PhantomSuite {
     val diff = 200
 
     val chain = for {
-      incr <-  database.counterTableTest.update.where(_.id eqs sample.id).modify(_.count_entries += 0).future()
+      _ <-  database.counterTableTest.update.where(_.id eqs sample.id).modify(_.count_entries += 0).future()
       select <- database.counterTableTest.select.where(_.id eqs sample.id).one
-      incr <-  database.counterTableTest.update.where(_.id eqs sample.id).modify(_.count_entries += diff).future()
+      _ <-  database.counterTableTest.update.where(_.id eqs sample.id).modify(_.count_entries += diff).future()
       select2 <- database.counterTableTest.select.where(_.id eqs sample.id).one
     } yield (select, select2)
 
@@ -79,13 +103,39 @@ class CounterColumnTest extends PhantomSuite {
     }
   }
 
+
+  it should "+= counter values by a given value using prepared statements" in {
+    val sample = gen[CounterRecord]
+    val added = gen[Long]
+
+    val query = database.counterTableTest
+      .update
+      .where(_.id eqs ?)
+      .modify(_.count_entries += ?)
+      .prepareAsync()
+
+    val chain = for {
+      _ <- database.counterTableTest.update
+        .where(_.id eqs sample.id)
+        .modify(_.count_entries += sample.count)
+        .future()
+      _ <-  query.flatMap(_.bind(added, sample.id).future())
+      select2 <- database.counterTableTest.select.where(_.id eqs sample.id).one
+    } yield select2
+
+
+    whenReady(chain) { res =>
+      res.value.count shouldEqual sample.count + added
+    }
+  }
+
   it should "-= counter values by 1" in {
     val sample = gen[CounterRecord]
 
     val chain = for {
-      incr1 <-  database.counterTableTest.update.where(_.id eqs sample.id).modify(_.count_entries += 1).future()
+      _ <- database.counterTableTest.update.where(_.id eqs sample.id).modify(_.count_entries += 1).future()
       select <- database.counterTableTest.select.where(_.id eqs sample.id).one()
-      incr <-  database.counterTableTest.update.where(_.id eqs sample.id).modify(_.count_entries -= 1).future()
+      _ <-  database.counterTableTest.update.where(_.id eqs sample.id).modify(_.count_entries -= 1).future()
       select2 <- database.counterTableTest.select.where(_.id eqs sample.id).one()
     } yield (select, select2)
 
@@ -96,14 +146,46 @@ class CounterColumnTest extends PhantomSuite {
     }
   }
 
+  it should "-= counter values by 1 using prepared statements" in {
+    val sample = gen[CounterRecord]
+
+    val query = database.counterTableTest
+      .update
+      .where(_.id eqs ?)
+      .modify(_.count_entries -= ?)
+      .prepareAsync()
+
+    val chain = for {
+      _ <- database.counterTableTest.update
+        .where(_.id eqs sample.id)
+        .modify(_.count_entries += sample.count)
+        .future()
+      _ <-  query.flatMap(_.bind(1L, sample.id).future())
+      select2 <- database.counterTableTest.select.where(_.id eqs sample.id).one
+    } yield select2
+
+
+    whenReady(chain) { res =>
+      res.value.count shouldEqual sample.count - 1
+    }
+  }
+
   it should "-= counter values by a given value" in {
     val sample = gen[CounterRecord]
     val diff = 200
     val initial = 500
 
     val chain = for {
-      incr <-  database.counterTableTest.update.where(_.id eqs sample.id).modify(_.count_entries += initial).future()
-      incr <- database.counterTableTest.update.where(_.id eqs sample.id).modify(_.count_entries -= diff).future()
+      _ <-  database.counterTableTest.update
+        .where(_.id eqs sample.id)
+        .modify(_.count_entries += initial)
+        .future()
+
+      _ <- database.counterTableTest.update
+        .where(_.id eqs sample.id)
+        .modify(_.count_entries -= diff)
+        .future()
+
       select2 <- database.counterTableTest.select.where(_.id eqs sample.id).one
     } yield select2
 
@@ -112,4 +194,29 @@ class CounterColumnTest extends PhantomSuite {
       res.value.count shouldEqual (initial - diff)
     }
   }
+
+  it should "-= counter values by a given value using prepared statements" in {
+    val sample = gen[CounterRecord]
+    val removed = gen[Long]
+
+    val query = database.counterTableTest
+      .update
+      .where(_.id eqs ?)
+      .modify(_.count_entries -= ?)
+      .prepareAsync()
+
+    val chain = for {
+      _ <- database.counterTableTest.update
+        .where(_.id eqs sample.id)
+        .modify(_.count_entries += sample.count)
+        .future()
+      _ <-  query.flatMap(_.bind(removed, sample.id).future())
+      select2 <- database.counterTableTest.select.where(_.id eqs sample.id).one
+    } yield select2
+
+
+    whenReady(chain) { res =>
+      res.value.count shouldEqual sample.count - removed
+    }
+  }
 }

phantom-thrift/src/test/scala/com/outworkers/phantom/thrift/tests/tjson/suites/ThriftSetOperationsTest.scala

@@ -37,8 +37,8 @@ class ThriftSetOperationsTest extends TJsonSuite {
       .future()
 
     val operation = for {
-      insertDone <- insert
-      update <- thriftDb.thriftColumnTable.update.where(_.id eqs id).modify(_.thriftSet add sample2).future()
+      _ <- insert
+      _ <- thriftDb.thriftColumnTable.update.where(_.id eqs id).modify(_.thriftSet add sample2).future()
       select <- thriftDb.thriftColumnTable.select(_.thriftSet).where(_.id eqs id).one
     } yield select
 
@@ -63,8 +63,8 @@ class ThriftSetOperationsTest extends TJsonSuite {
       .future()
 
     val operation = for {
-      insertDone <- insert
-      update <- thriftDb.thriftColumnTable.update.where(_.id eqs id).modify(_.thriftSet addAll Set(sample2, sample3)).future()
+      _ <- insert
+      _ <- thriftDb.thriftColumnTable.update.where(_.id eqs id).modify(_.thriftSet addAll Set(sample2, sample3)).future()
       select <- thriftDb.thriftColumnTable.select(_.thriftSet).where(_.id eqs id).one
     } yield select
 
@@ -89,8 +89,8 @@ class ThriftSetOperationsTest extends TJsonSuite {
       .future()
 
     val operation = for {
-      insertDone <- insert
-      update <- thriftDb.thriftColumnTable.update.where(_.id eqs id).modify(_.thriftSet remove sample3).future()
+      _ <- insert
+      _ <- thriftDb.thriftColumnTable.update.where(_.id eqs id).modify(_.thriftSet remove sample3).future()
       select <- thriftDb.thriftColumnTable.select(_.thriftSet).where(_.id eqs id).one
     } yield select
 
@@ -113,8 +113,8 @@ class ThriftSetOperationsTest extends TJsonSuite {
       .value(_.thriftSet, Set(sample, sample2, sample3))
 
     val operation = for {
-      insertDone <- insert.future()
-      update <- thriftDb
+      _ <- insert.future()
+      _ <- thriftDb
         .thriftColumnTable.update.where(_.id eqs id)
         .modify(_.thriftSet removeAll Set(sample2, sample3))
         .future()