review.fuel-infra Code Review - packages/trusty/mysql-wsrep-5.6.git/blob

   1 /*
   2    Copyright 2010 Sun Microsystems, Inc.
   3    All rights reserved. Use is subject to license terms.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; version 2 of the License.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
  17 */
  18
  19 package testsuite.clusterj;
  20
  21 import testsuite.clusterj.model.Employee;
  22 import com.mysql.clusterj.query.QueryBuilder;
  23 import com.mysql.clusterj.query.QueryDomainType;
  24 import com.mysql.clusterj.query.Predicate;
  25 import com.mysql.clusterj.query.PredicateOperand;
  26
  27 import com.mysql.clusterj.Query;
  28
  29 import java.util.HashSet;
  30 import java.util.List;
  31 import java.util.Set;
  32
  33 public class QueryPrimaryKeyTest extends AbstractClusterJModelTest {
  34
  35     @Override
  36     public void localSetUp() {
  37         createSessionFactory();
  38         session = sessionFactory.getSession();
  39         tx = session.currentTransaction();
  40         createEmployeeInstances(10);
  41         try {
  42             tx.begin();
  43             session.deletePersistentAll(Employee.class);
  44             tx.commit();
  45         } catch (Throwable t) {
  46             // ignore errors while deleting
  47         }
  48         tx.begin();
  49         session.makePersistentAll(employees);
  50         tx.commit();
  51         addTearDownClasses(Employee.class);
  52     }
  53
  54     /** Test all queries using the same setup.
  55      * Fail if any errors during the tests.
  56      */
  57     public void testPrimaryKey() {
  58         primaryKeyBetweenQuery();
  59         primaryKeyEqualQuery();
  60         primaryKeyGreaterEqualQuery();
  61         primaryKeyGreaterThanQuery();
  62         primaryKeyLessEqualQuery();
  63         primaryKeyLessThanQuery();
  64         failOnError();
  65     }
  66     public void primaryKeyEqualQuery() {
  67
  68         tx.begin();
  69         // QueryBuilder is the sessionFactory for queries
  70         QueryBuilder builder = session.getQueryBuilder();
  71         // QueryDomainType is the main interface
  72         QueryDomainType dobj = builder.createQueryDefinition(Employee.class);
  73
  74         // parameter name
  75         PredicateOperand param = dobj.param("id");
  76         // property name
  77         PredicateOperand column = dobj.get("id");
  78         // compare the column with the parameter
  79         Predicate compare = column.equal(param);
  80         // set the where clause into the query
  81         dobj.where(compare);
  82         // create a query instance
  83         Query query = session.createQuery(dobj);
  84
  85         // set the parameter value
  86         query.setParameter("id", 8);
  87         // get the results
  88         List<Employee> results = query.getResultList();
  89         // consistency check the results
  90         consistencyCheck(results);
  91         // verify we got the right instance
  92         errorIfNotEqual("Wrong employee id returned from query: ",
  93                 8, results.get(0).getId());
  94         tx.commit();
  95     }
  96
  97     public void primaryKeyGreaterThanQuery() {
  98
  99         tx.begin();
 100         // QueryBuilder is the sessionFactory for queries
 101         QueryBuilder builder = session.getQueryBuilder();
 102         // QueryDomainType is the main interface
 103         QueryDomainType dobj = builder.createQueryDefinition(Employee.class);
 104
 105         // parameter name
 106         PredicateOperand param = dobj.param("id");
 107         // property name
 108         PredicateOperand column = dobj.get("id");
 109         // compare the column with the parameter
 110         Predicate compare = column.greaterThan(param);
 111         // set the where clause into the query
 112         dobj.where(compare);
 113         // create a query instance
 114         Query query = session.createQuery(dobj);
 115
 116         // set the parameter values
 117         query.setParameter("id", 6);
 118         // get the results
 119         List<Employee> results = query.getResultList();
 120         // consistency check the results
 121         consistencyCheck(results);
 122         // verify we got the right instances
 123         Set<Integer> expected = new HashSet<Integer>();
 124         expected.add(7);
 125         expected.add(8);
 126         expected.add(9);
 127         Set<Integer> actual = new HashSet<Integer>();
 128         for (Employee emp: results) {
 129             actual.add(emp.getId());
 130         }
 131         errorIfNotEqual("Wrong employee ids returned from query: ",
 132                 expected, actual);
 133         tx.commit();
 134     }
 135
 136     public void primaryKeyGreaterEqualQuery() {
 137
 138         tx.begin();
 139         // QueryBuilder is the sessionFactory for queries
 140         QueryBuilder builder = session.getQueryBuilder();
 141         // QueryDomainType is the main interface
 142         QueryDomainType dobj = builder.createQueryDefinition(Employee.class);
 143
 144         // parameter name
 145         PredicateOperand param = dobj.param("id");
 146         // property name
 147         PredicateOperand column = dobj.get("id");
 148         // compare the column with the parameter
 149         Predicate compare = column.greaterEqual(param);
 150         // set the where clause into the query
 151         dobj.where(compare);
 152         // create a query instance
 153         Query query = session.createQuery(dobj);
 154
 155         // set the parameter values
 156         query.setParameter("id", 7);
 157         // get the results
 158         List<Employee> results = query.getResultList();
 159         // consistency check the results
 160         consistencyCheck(results);
 161         // verify we got the right instances
 162         Set<Integer> expected = new HashSet<Integer>();
 163         expected.add(7);
 164         expected.add(8);
 165         expected.add(9);
 166         Set<Integer> actual = new HashSet<Integer>();
 167         for (Employee emp: results) {
 168             actual.add(emp.getId());
 169         }
 170         errorIfNotEqual("Wrong employee ids returned from query: ",
 171                 expected, actual);
 172         tx.commit();
 173     }
 174
 175     public void primaryKeyLessThanQuery() {
 176
 177         tx.begin();
 178         // QueryBuilder is the sessionFactory for queries
 179         QueryBuilder builder = session.getQueryBuilder();
 180         // QueryDomainType is the main interface
 181         QueryDomainType dobj = builder.createQueryDefinition(Employee.class);
 182
 183         // parameter name
 184         PredicateOperand param = dobj.param("id");
 185         // property name
 186         PredicateOperand column = dobj.get("id");
 187         // compare the column with the parameter
 188         Predicate compare = column.lessThan(param);
 189         // set the where clause into the query
 190         dobj.where(compare);
 191         // create a query instance
 192         Query query = session.createQuery(dobj);
 193
 194         // set the parameter values
 195         query.setParameter("id", 3);
 196         // get the results
 197         List<Employee> results = query.getResultList();
 198         // consistency check the results
 199         consistencyCheck(results);
 200         // verify we got the right instances
 201         Set<Integer> expected = new HashSet<Integer>();
 202         expected.add(0);
 203         expected.add(1);
 204         expected.add(2);
 205         Set<Integer> actual = new HashSet<Integer>();
 206         for (Employee emp: results) {
 207             actual.add(emp.getId());
 208         }
 209         errorIfNotEqual("Wrong employee ids returned from query: ",
 210                 expected, actual);
 211         tx.commit();
 212     }
 213
 214     public void primaryKeyLessEqualQuery() {
 215
 216         tx.begin();
 217         // QueryBuilder is the sessionFactory for queries
 218         QueryBuilder builder = session.getQueryBuilder();
 219         // QueryDomainType is the main interface
 220         QueryDomainType dobj = builder.createQueryDefinition(Employee.class);
 221
 222         // parameter name
 223         PredicateOperand param = dobj.param("id");
 224         // property name
 225         PredicateOperand column = dobj.get("id");
 226         // compare the column with the parameter
 227         Predicate compare = column.lessEqual(param);
 228         // set the where clause into the query
 229         dobj.where(compare);
 230         // create a query instance
 231         Query query = session.createQuery(dobj);
 232
 233         // set the parameter values
 234         query.setParameter("id", 2);
 235         // get the results
 236         List<Employee> results = query.getResultList();
 237         // consistency check the results
 238         consistencyCheck(results);
 239         // verify we got the right instances
 240         Set<Integer> expected = new HashSet<Integer>();
 241         expected.add(0);
 242         expected.add(1);
 243         expected.add(2);
 244         Set<Integer> actual = new HashSet<Integer>();
 245         for (Employee emp: results) {
 246             actual.add(emp.getId());
 247         }
 248         errorIfNotEqual("Wrong employee ids returned from query: ",
 249                 expected, actual);
 250         tx.commit();
 251     }
 252
 253     public void primaryKeyBetweenQuery() {
 254
 255         tx.begin();
 256         // QueryBuilder is the sessionFactory for queries
 257         QueryBuilder builder = session.getQueryBuilder();
 258         // QueryDomainType is the main interface
 259         QueryDomainType dobj = builder.createQueryDefinition(Employee.class);
 260
 261         // parameter name
 262         PredicateOperand lower = dobj.param("lower");
 263         // parameter name
 264         PredicateOperand upper = dobj.param("upper");
 265         // property name
 266         PredicateOperand column = dobj.get("id");
 267         // compare the column with the parameter
 268         Predicate compare = column.between(lower, upper);
 269         // set the where clause into the query
 270         dobj.where(compare);
 271         // create a query instance
 272         Query query = session.createQuery(dobj);
 273
 274         // set the parameter values
 275         query.setParameter("lower", 5);
 276         query.setParameter("upper", 7);
 277         // get the results
 278         List<Employee> results = query.getResultList();
 279         // consistency check the results
 280         consistencyCheck(results);
 281         // verify we got the right instances
 282         Set<Integer> expected = new HashSet<Integer>();
 283         expected.add(5);
 284         expected.add(6);
 285         expected.add(7);
 286         Set<Integer> actual = new HashSet<Integer>();
 287         for (Employee emp: results) {
 288             actual.add(emp.getId());
 289         }
 290         errorIfNotEqual("Wrong employee ids returned from query: ",
 291                 expected, actual);
 292         tx.commit();
 293     }
 294 }