From 7eeede9ac308bc60e52e77c6681127014c8ec933 Mon Sep 17 00:00:00 2001
From: debasishg <dghosh@acm.org>
Date: Thu, 13 Aug 2009 22:16:47 +0530
Subject: [PATCH] added remove functions for Map storage + added test cases +
 made getStorageRangeFor same in semantics as Cassandra impl

---
 .../src/main/scala/state/MongoStorage.scala   | 40 +++++++++----
 kernel/src/test/scala/MongoStorageSpec.scala  | 56 +++++++++++++++++++
 2 files changed, 85 insertions(+), 11 deletions(-)

diff --git a/kernel/src/main/scala/state/MongoStorage.scala b/kernel/src/main/scala/state/MongoStorage.scala
index 73f43b55c3..ec903aa2e9 100644
--- a/kernel/src/main/scala/state/MongoStorage.scala
+++ b/kernel/src/main/scala/state/MongoStorage.scala
@@ -65,16 +65,22 @@ object MongoStorage extends MapStorage
   }
 
   override def removeMapStorageFor(name: String, key: AnyRef) = {
+    nullSafeFindOne(name) match {
+      case None => 
+      case Some(dbo) => {
+        val orig = dbo.get(VALUE).asInstanceOf[DBObject].toMap
+        orig.remove(key.asInstanceOf[String])
+
+        // remove existing reference
+        removeMapStorageFor(name)
+        // and insert
+        coll.insert(new BasicDBObject().append(KEY, name).append(VALUE, orig))
+      }
+    }
   }
   
   override def getMapStorageEntryFor(name: String, key: AnyRef): Option[AnyRef] = {
-    try {
-      getValueForKey(name, key.asInstanceOf[String])
-    } catch {
-      case e =>
-        e.printStackTrace
-        None
-    }
+    getValueForKey(name, key.asInstanceOf[String])
   }
   
   override def getMapStorageSizeFor(name: String): Int = {
@@ -104,7 +110,6 @@ object MongoStorage extends MapStorage
   override def getMapStorageRangeFor(name: String, start: Option[AnyRef], 
                             finish: Option[AnyRef], 
                             count: Int): List[Tuple2[AnyRef, AnyRef]] = {
-    // @fixme: currently ignores finish
     val m = 
       nullSafeFindOne(name) match {
         case None => 
@@ -112,9 +117,22 @@ object MongoStorage extends MapStorage
         case Some(dbo) =>
           dbo.get(VALUE).asInstanceOf[JMap[String, AnyRef]]
       }
-    val s = start.get.asInstanceOf[Int]
+
+    /**
+     * <tt>count</tt> is the max number of results to return. Start with 
+     * <tt>start</tt> or 0 (if <tt>start</tt> is not defined) and go until
+     * you hit <tt>finish</tt> or <tt>count</tt>.
+     */
+    val s = if (start.isDefined) start.get.asInstanceOf[Int] else 0
+    val cnt = 
+      if (finish.isDefined) {
+        val f = finish.get.asInstanceOf[Int]
+        if (f >= s) Math.min(count, (f - s)) else count
+      }
+      else count
+
     val n = 
-      List(m.keySet.toArray: _*).asInstanceOf[List[String]].sort((e1, e2) => (e1 compareTo e2) < 0).slice(s, s + count)
+      List(m.keySet.toArray: _*).asInstanceOf[List[String]].sort((e1, e2) => (e1 compareTo e2) < 0).slice(s, s + cnt)
     val vals = 
       for(s <- n) 
         yield (s, serializer.in(m.get(s).asInstanceOf[Array[Byte]], None))
@@ -137,7 +155,7 @@ object MongoStorage extends MapStorage
     }
   }
   
-  def insertVectorStorageEntriesFor(name: String, elements: List[AnyRef]) = {
+  override def insertVectorStorageEntriesFor(name: String, elements: List[AnyRef]) = {
     val q = new BasicDBObject
     q.put(KEY, name)
     
diff --git a/kernel/src/test/scala/MongoStorageSpec.scala b/kernel/src/test/scala/MongoStorageSpec.scala
index 7d0f56d2f4..5baa03baae 100644
--- a/kernel/src/test/scala/MongoStorageSpec.scala
+++ b/kernel/src/test/scala/MongoStorageSpec.scala
@@ -193,6 +193,7 @@ class MongoStorageSpec extends TestCase {
     changeSetM += "5" -> Map(1 -> "dg", 2 -> "mc")
     MongoStorage.insertMapStorageEntriesFor("U-M1", changeSetM.toList)
 
+    // specify start and count
     val l: List[Tuple2[AnyRef, AnyRef]] = 
       MongoStorage.getMapStorageRangeFor(
         "U-M1", Some(Integer.valueOf(2)), None, 3)
@@ -203,6 +204,61 @@ class MongoStorageSpec extends TestCase {
     assertEquals("4", l(1)._1.asInstanceOf[String])
     assertEquals(List(10, 20, 30), l(1)._2.asInstanceOf[List[Int]])
     
+    // specify start, finish and count where finish - start == count
+    assertEquals(3,
+      MongoStorage.getMapStorageRangeFor(
+        "U-M1", Some(Integer.valueOf(2)), Some(Integer.valueOf(5)), 3).size)
+
+    // specify start, finish and count where finish - start > count
+    assertEquals(3,
+      MongoStorage.getMapStorageRangeFor(
+        "U-M1", Some(Integer.valueOf(2)), Some(Integer.valueOf(9)), 3).size)
+
+    // do not specify start or finish 
+    assertEquals(3,
+      MongoStorage.getMapStorageRangeFor(
+        "U-M1", None, None, 3).size)
+
+    // specify finish and count 
+    assertEquals(3,
+      MongoStorage.getMapStorageRangeFor(
+        "U-M1", None, Some(Integer.valueOf(3)), 3).size)
+
+    // specify start, finish and count where finish < start
+    assertEquals(3,
+      MongoStorage.getMapStorageRangeFor(
+        "U-M1", Some(Integer.valueOf(2)), Some(Integer.valueOf(1)), 3).size)
+
+    changeSetM.clear
+  }
+
+  @Test
+  def testMapStorageRemove = {
+    fillMap
+    changeSetM += "5" -> Map(1 -> "dg", 2 -> "mc")
+
+    MongoStorage.insertMapStorageEntriesFor("U-M1", changeSetM.toList)
+    assertEquals(5,
+      MongoStorage.getMapStorageSizeFor("U-M1"))
+
+    // remove key "3"
+    MongoStorage.removeMapStorageFor("U-M1", "3")
+    assertEquals(4,
+      MongoStorage.getMapStorageSizeFor("U-M1"))
+
+    try {
+      MongoStorage.getMapStorageEntryFor("U-M1", "3")
+      fail("should throw exception")
+    } catch { case e => {}}
+
+    // remove the whole stuff
+    MongoStorage.removeMapStorageFor("U-M1")
+
+    try {
+      MongoStorage.getMapStorageFor("U-M1")
+      fail("should throw exception")
+    } catch { case e: NoSuchElementException => {}}
+
     changeSetM.clear
   }