Mercurial > hg > release > thermostat-0.5

changeset 922:beda9a88a646

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fix query to allow chain where clauses review-thread: http://icedtea.classpath.org/pipermail/thermostat/2013-January/005238.html reviewwed-by: jerboaa
author Mario Torre <neugens.limasoftware@gmail.com>
date Fri, 18 Jan 2013 19:39:01 +0100
parents 5c92b1c6da21
children 3b9daf9ded8f
files storage/core/src/main/java/com/redhat/thermostat/storage/core/Query.java storage/mongo/src/main/java/com/redhat/thermostat/storage/mongodb/internal/MongoQuery.java storage/mongo/src/test/java/com/redhat/thermostat/storage/mongodb/internal/MongoQueryTest.java
diffstat 3 files changed, 90 insertions(+), 26 deletions(-) [+]
line wrap: on
line diff
--- a/storage/core/src/main/java/com/redhat/thermostat/storage/core/Query.java	Fri Jan 18 19:39:00 2013 +0100
+++ b/storage/core/src/main/java/com/redhat/thermostat/storage/core/Query.java	Fri Jan 18 19:39:01 2013 +0100
@@ -51,7 +51,7 @@
         LESS_THAN,
         LESS_THAN_OR_EQUAL_TO,
     }
-
+    
     enum SortDirection {
         ASCENDING(1),
         DESCENDING(-1);
@@ -68,7 +68,7 @@
     }
 
     <S> void where(Key<S> key, Criteria criteria, S value);
-
+    
     void sort(Key<?> key, SortDirection direction);
 
     void limit(int n);
--- a/storage/mongo/src/main/java/com/redhat/thermostat/storage/mongodb/internal/MongoQuery.java	Fri Jan 18 19:39:00 2013 +0100
+++ b/storage/mongo/src/main/java/com/redhat/thermostat/storage/mongodb/internal/MongoQuery.java	Fri Jan 18 19:39:01 2013 +0100
@@ -36,9 +36,13 @@
 
 package com.redhat.thermostat.storage.mongodb.internal;
 
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 
 import com.mongodb.BasicDBObject;
+import com.mongodb.BasicDBObjectBuilder;
 import com.mongodb.DBObject;
 import com.redhat.thermostat.storage.core.AbstractQuery;
 import com.redhat.thermostat.storage.core.Category;
@@ -50,6 +54,8 @@
 
     private MongoStorage storage;
     private BasicDBObject query = new BasicDBObject();
+    private Map<String, BasicDBObjectBuilder> builerMap;
+    
     private boolean hasClauses = false;
     private Category<T> category;
     private Class<T> resultClass;
@@ -58,6 +64,7 @@
         this.storage = storage;
         this.category = category;
         this.resultClass = category.getDataClass();
+        this.builerMap = new HashMap<String, BasicDBObjectBuilder>();
     }
 
     public Category<T> getCategory() {
@@ -74,31 +81,45 @@
     }
 
     public void where(String key, Criteria operator, Object value) {
-        switch (operator) {
-        case EQUALS:
+
+        // strict equality is mutually exclusive on the key
+        if (operator.equals(Criteria.EQUALS)) {
             query.put(key, value);
-            break;
-
-        case NOT_EQUAL_TO:
-            query.put(key, new BasicDBObject("$ne", value));
-            break;
-
-        case LESS_THAN:
-            query.put(key, new BasicDBObject("$lt", value));
-            break;
-
-        case LESS_THAN_OR_EQUAL_TO:
-            query.put(key, new BasicDBObject("$lte", value));
-            break;
-        case GREATER_THAN:
-            query.put(key, new BasicDBObject("$gt", value));
-            break;
-
-        case GREATER_THAN_OR_EQUAL_TO:
-            query.put(key, new BasicDBObject("$gte", value));
-            break;
-        default:
-            throw new IllegalArgumentException("MongoQuery can not handle " + operator);
+        
+        } else {
+            BasicDBObjectBuilder queryParameters = null;
+            if (builerMap.containsKey(key)) {
+                queryParameters = (BasicDBObjectBuilder) builerMap.get(key);
+            } else {
+                queryParameters = BasicDBObjectBuilder.start();
+                builerMap.put(key, queryParameters);
+            }
+            
+            switch (operator) {
+    
+            case NOT_EQUAL_TO:
+                queryParameters.add("$ne", value);
+                break;
+    
+            case LESS_THAN:
+                queryParameters.add("$lt", value);
+                break;
+    
+            case LESS_THAN_OR_EQUAL_TO:
+                queryParameters.add("$lte", value);
+                break;
+            case GREATER_THAN:
+                queryParameters.add("$gt", value);
+                break;
+    
+            case GREATER_THAN_OR_EQUAL_TO:
+                queryParameters.add("$gte", value);
+                break;
+    
+            default:
+                throw new IllegalArgumentException("MongoQuery can not handle " + operator);
+            }
+            query.put(key, queryParameters.get());
         }
         hasClauses = true;
     }
--- a/storage/mongo/src/test/java/com/redhat/thermostat/storage/mongodb/internal/MongoQueryTest.java	Fri Jan 18 19:39:00 2013 +0100
+++ b/storage/mongo/src/test/java/com/redhat/thermostat/storage/mongodb/internal/MongoQueryTest.java	Fri Jan 18 19:39:01 2013 +0100
@@ -45,6 +45,7 @@
 import org.junit.Test;
 
 import com.mongodb.BasicDBObject;
+import com.mongodb.BasicDBObjectBuilder;
 import com.mongodb.DBObject;
 import com.redhat.thermostat.storage.core.Category;
 import com.redhat.thermostat.storage.core.Query.Criteria;
@@ -121,6 +122,48 @@
         assertEquals(new BasicDBObject("$lte", "value"), generatedQuery.get("key"));
     }
 
+    @Test
+    public void testMultiWhere() {
+        MongoQuery<TestClass> query = new MongoQuery<>(storage, category);
+        query.where("test", Criteria.LESS_THAN_OR_EQUAL_TO, 1);
+        query.where("test", Criteria.GREATER_THAN, 2);
+
+        DBObject generatedQuery = query.getGeneratedQuery();
+        DBObject dbObject = BasicDBObjectBuilder.start("$lte", 1).add("$gt", 2).get();
+        assertEquals(dbObject, generatedQuery.get("test"));
+    }
+    
+    @Test
+    public void testMultiWhere2() {
+        MongoQuery<TestClass> query = new MongoQuery<>(storage, category);
+        query.where("test", Criteria.LESS_THAN_OR_EQUAL_TO, 1);
+        query.where("test2", Criteria.GREATER_THAN, 2);
+
+        DBObject generatedQuery = query.getGeneratedQuery();
+        assertEquals(new BasicDBObject("$lte", 1), generatedQuery.get("test"));
+    }
+    
+    @Test
+    public void testMultiWhere3() {
+        MongoQuery<TestClass> query = new MongoQuery<>(storage, category);
+        query.where("test", Criteria.EQUALS, 1);
+        query.where("test", Criteria.GREATER_THAN, 2);
+
+        DBObject generatedQuery = query.getGeneratedQuery();
+        assertEquals(new BasicDBObject("$gt", 2), generatedQuery.get("test"));
+    }
+    
+    @Test
+    public void testMultiWhere4() {
+        MongoQuery<TestClass> query = new MongoQuery<>(storage, category);
+        query.where("test", Criteria.EQUALS, 1);
+        query.where("test2", Criteria.GREATER_THAN, 2);
+
+        DBObject generatedQuery = query.getGeneratedQuery();
+        assertEquals(1, generatedQuery.get("test"));
+        assertEquals(new BasicDBObject("$gt", 2), generatedQuery.get("test2"));
+    }
+    
     private DBObject generateSimpleWhereQuery(String key, Criteria criteria, Object value) {
         MongoQuery<TestClass> query = new MongoQuery<>(storage, category);
         query.where(key, criteria, value);