public void conc(ExtObjectContainer oc) { Query q = oc.query(); q.constrain(QueryForUnknownFieldTestCase.class); q.descend("_name").constrain("name"); Assert.areEqual(1, q.execute().size()); q = oc.query(); q.constrain(QueryForUnknownFieldTestCase.class); q.descend("name").constrain("name"); Assert.areEqual(0, q.execute().size()); }
private Item itemByName(String string) { Query q = db().query(); q.constrain(Item.class); q.descend("_name").constrain(string); Object object = q.execute().next(); return (Item) object; }
public void conc(ExtObjectContainer oc) { oc.queryByExample((new QueryNonExistantTestCase(true))); assertOccurrences(oc, QueryNonExistantTestCase.class, 0); Query q = oc.query(); q.constrain(new QueryNonExistantTestCase(true)); Assert.areEqual(0, q.execute().size()); }
private void restoreMembers(Data data) { Query q = newQuery(Data.class); ObjectSet objectSet = q.execute(); Data rdata = (Data) objectSet.next(); data.i_map = rdata.i_map; data.i_helper = rdata.i_helper; }
public void concRead(ExtObjectContainer oc) { for (int i = 0; i < COUNT; i++) { Query q = oc.query(); q.constrain(Atom.class); q.descend("name").constrain("ibi" + i); ObjectSet objectSet = q.execute(); Assert.areEqual(1, objectSet.size()); Atom child = (Atom) objectSet.next(); q = oc.query(); q.constrain(IndexedByIdentityTestCase.class); q.descend("atom").constrain(child).identity(); objectSet = q.execute(); Assert.areEqual(1, objectSet.size()); IndexedByIdentityTestCase ibi = (IndexedByIdentityTestCase) objectSet.next(); Assert.areSame(child, ibi.atom); } }
public void checkUpdateSameObject(ExtObjectContainer oc) throws Exception { Query query = oc.query(); query.descend("_s").constrain(testString + COUNT / 2); ObjectSet result = query.execute(); Assert.areEqual(1, result.size()); SimpleObject o = (SimpleObject) result.next(); int i = o.getI(); Assert.isTrue(COUNT <= i && i < COUNT + threadCount()); }
public void concUpdateSameObject(ExtObjectContainer oc, int seq) throws Exception { Query query = oc.query(); query.descend("_s").constrain(testString + COUNT / 2); ObjectSet result = query.execute(); Assert.areEqual(1, result.size()); SimpleObject o = (SimpleObject) result.next(); o.setI(COUNT + seq); oc.store(o); }
public void testAllThere() throws Exception { for (int i = 0; i < FOOS.length; i++) { Query q = createQuery(FOOS[i]); ObjectSet objectSet = q.execute(); Assert.areEqual(1, objectSet.size()); FieldIndexItem fii = (FieldIndexItem) objectSet.next(); Assert.areEqual(FOOS[i], fii.foo); } }
private void assertQueryForTimestamp(Item expected, long timestamp) { Query query = db().query(); query.constrain(Item.class); query.descend(VirtualField.COMMIT_TIMESTAMP).constrain(timestamp); ObjectSet<Object> objectSet = query.execute(); Assert.areEqual(1, objectSet.size()); Item actual = (Item) objectSet.next(); Assert.areSame(expected, actual); }
public void testUpdate() { ExtObjectContainer oc = fixture().db(); initGenericObjects(); // Db4oUtil.dump(oc); ReflectClass rc = getReflectClass(oc, PERSON_CLASSNAME); Assert.isNotNull(rc); Query q = oc.query(); q.constrain(rc); ObjectSet results = q.execute(); // Db4oUtil.dumpResults(oc, results); Assert.isTrue(results.size() == 1); }
public void testDelete() { ExtObjectContainer oc = fixture().db(); initGenericObjects(); ReflectClass rc = getReflectClass(oc, PERSON_CLASSNAME); Assert.isNotNull(rc); Query q = oc.query(); q.constrain(rc); ObjectSet results = q.execute(); while (results.hasNext()) { Object o = results.next(); oc.delete(o); } oc.commit(); // now query to make sure there are none left q = oc.query(); q.constrain(rc); q.descend("surname").constrain("John"); results = q.execute(); Assert.isTrue(results.size() == 0); }
public void concUpdate(ExtObjectContainer oc, int seq) throws Exception { Query q = oc.query(); q.constrain(IndexedByIdentityTestCase.class); ObjectSet os = q.execute(); Assert.areEqual(COUNT, os.size()); while (os.hasNext()) { IndexedByIdentityTestCase idi = (IndexedByIdentityTestCase) os.next(); idi.atom.name = "updated" + seq; oc.store(idi); Thread.sleep(100); } }
public void concUpdateDifferentObject(ExtObjectContainer oc, int seq) throws Exception { Query query = oc.query(); query .descend("_s") .constrain(testString + seq) .and(query.descend("_i").constrain(new Integer(seq))); ObjectSet result = query.execute(); Assert.areEqual(1, result.size()); SimpleObject o = (SimpleObject) result.next(); o.setI(seq + COUNT); oc.store(o); }
public void testQueryForVersionNumber() { store(new Item(NEWER)); db().commit(); Item newer = itemByName(NEWER); long version = version(newer); Query query = db().query(); query.descend(VirtualField.COMMIT_TIMESTAMP).constrain(new Long(version)).smaller().not(); ObjectSet<Item> set = query.execute(); Assert.areEqual(1, set.size()); Assert.areSame(newer, set.next()); }
public void testCreate() throws Exception { initGenericObjects(); // fixture().reopen(); ExtObjectContainer oc = fixture().db(); // now check to see if person was saved ReflectClass rc = getReflectClass(oc, PERSON_CLASSNAME); Assert.isNotNull(rc); Query q = oc.query(); q.constrain(rc); ObjectSet results = q.execute(); Assert.isTrue(results.size() == 1); // Db4oUtil.dumpResults(fixture().db(), results); }
public void checkUpdate(ExtObjectContainer oc) { Query q = oc.query(); q.constrain(IndexedByIdentityTestCase.class); ObjectSet os = q.execute(); Assert.areEqual(COUNT, os.size()); String expected = null; while (os.hasNext()) { IndexedByIdentityTestCase idi = (IndexedByIdentityTestCase) os.next(); if (expected == null) { expected = idi.atom.name; Assert.isTrue(expected.startsWith("updated")); Assert.isTrue(expected.length() > "updated".length()); } Assert.areEqual(expected, idi.atom.name); } }
private void tExpectInts(Query q, int[] ints, int zeroSize) { ObjectSet res = q.execute(); Assert.areEqual(ints.length + zeroSize, res.size()); while (res.hasNext()) { CreateIndexFor ci = (CreateIndexFor) res.next(); for (int i = 0; i < ints.length; i++) { if (ints[i] == ci.i_int) { ints[i] = 0; break; } } } for (int i = 0; i < ints.length; i++) { Assert.areEqual(0, ints[i]); } }
private void assertNoItemFoundByQuery() { Query q = db().query(); q.constrain(Item.class); Assert.areEqual(0, q.execute().size()); }
/** @deprecated using deprecated api */ private void runElementTest(Data data, boolean onOriginal) throws Exception { Map otherMap = new HashMap(); AtomData atom = null; tDefaultValues(data); int itCount = 0; Iterator i = data.i_map.keySet().iterator(); while (i.hasNext()) { String str = (String) i.next(); itCount++; atom = (AtomData) data.i_map.get(str); Assert.areEqual(str, atom.name); otherMap.put(str, atom); } Assert.areEqual(DEFAULT.length, itCount); Assert.areEqual(DEFAULT.length, data.i_map.size()); Assert.isFalse(data.i_map.isEmpty()); db().deactivate(data.i_map, Integer.MAX_VALUE); data.i_map.get("great"); Assert.areEqual("great", ((AtomData) data.i_map.get("great")).name); db().deactivate(data.i_map, Integer.MAX_VALUE); if (onOriginal) { Query q = newQuery(); Data template = new Data(); template.i_map = db().collections().newHashMap(1); template.i_map.put("cool", new AtomData("cool")); q.constrain(template); ObjectSet qResult = q.execute(); Assert.areEqual(1, qResult.size()); Assert.areEqual(data, qResult.next()); } Assert.isTrue(data.i_map.keySet().containsAll(otherMap.keySet())); Object[] arr = data.i_map.keySet().toArray(); tDefaultArray(arr); String[] cmp = new String[DEFAULT.length]; System.arraycopy(DEFAULT, 0, cmp, 0, DEFAULT.length); i = data.i_map.keySet().iterator(); while (i.hasNext()) { String str = (String) i.next(); boolean found = false; for (int j = 0; j < cmp.length; j++) { if (str.equals(cmp[j])) { cmp[j] = null; found = true; } } Assert.isTrue(found); } for (int j = 0; j < cmp.length; j++) { Assert.isNull(cmp[j]); } db().deactivate(data.i_map, Integer.MAX_VALUE); Assert.isFalse(data.i_map.isEmpty()); db().deactivate(data.i_map, Integer.MAX_VALUE); data.i_map.put("yup", new AtomData("yup")); db().store(data.i_map); db().store(data.i_map); db().store(data.i_map); db().store(data.i_helper); db().store(data.i_helper); db().store(data.i_helper); db().commit(); Assert.areEqual(4, data.i_map.size()); atom = (AtomData) data.i_map.get("yup"); Assert.areEqual("yup", atom.name); AtomData removed = (AtomData) data.i_map.remove("great"); Assert.areEqual("great", removed.name); Assert.isNull(data.i_map.remove("great")); db().deactivate(data.i_map, Integer.MAX_VALUE); Assert.areEqual(3, data.i_map.size()); Assert.isTrue(data.i_map.keySet().removeAll(otherMap.keySet())); db().deactivate(data.i_map, Integer.MAX_VALUE); Assert.isFalse(data.i_map.keySet().removeAll(otherMap.keySet())); Assert.areEqual(1, data.i_map.size()); i = data.i_map.keySet().iterator(); String str = (String) i.next(); Assert.areEqual("yup", str); Assert.isFalse(i.hasNext()); data.i_map.clear(); Assert.isTrue(data.i_map.isEmpty()); Assert.areEqual(0, data.i_map.size()); setDefaultValues(data.i_map); String[] strArr = new String[1]; strArr = (String[]) data.i_map.keySet().toArray(strArr); tDefaultArray(strArr); data.i_map.clear(); data.i_map.put("zero", "zero"); for (int j = 0; j < COUNT; j++) { data.i_map.put(MORE + j, new AtomData(MORE + j)); } Assert.areEqual(COUNT + 1, data.i_map.size()); lookupLast(data); db().deactivate(data.i_map, Integer.MAX_VALUE); lookupLast(data); lookupLast(data); reopen(); restoreMembers(data); lookupLast(data); atom = new AtomData("double"); data.i_map.put("double", atom); int previousSize = data.i_map.size(); db().deactivate(data.i_map, Integer.MAX_VALUE); AtomData doubleAtom = (AtomData) data.i_map.put("double", new AtomData("double")); Assert.areSame(atom, doubleAtom); Assert.areEqual(previousSize, data.i_map.size()); data.i_map.put("double", doubleAtom); db().commit(); data.i_map.put("rollBack", "rollBack"); data.i_map.put("double", new AtomData("nono")); db().rollback(); Assert.isNull(data.i_map.get("rollBack")); Assert.areEqual(previousSize, data.i_map.size()); atom = (AtomData) data.i_map.get("double"); Assert.areSame(atom, doubleAtom); Assert.isTrue(data.i_map.containsKey("double")); Assert.isFalse(data.i_map.containsKey("rollBack")); otherMap.clear(); otherMap.put("other1", doubleAtom); otherMap.put("other2", doubleAtom); data.i_map.putAll(otherMap); db().deactivate(data.i_map, Integer.MAX_VALUE); Assert.areSame(doubleAtom, data.i_map.get("other1")); Assert.areSame(doubleAtom, data.i_map.get("other2")); data.i_map.clear(); Assert.areEqual(0, data.i_map.size()); setDefaultValues(data.i_map); int j = 0; i = data.i_map.keySet().iterator(); while (i.hasNext()) { String key = (String) i.next(); if (key.equals("cool")) { i.remove(); } j++; } Assert.areEqual(2, data.i_map.size()); Assert.isFalse(data.i_map.containsKey("cool")); Assert.areEqual(3, j); data.i_map.put("double", doubleAtom); ((Db4oMap) data.i_map).deleteRemoved(true); data.i_map.keySet().remove("double"); Assert.isFalse(db().isStored(doubleAtom)); ((Db4oMap) data.i_map).deleteRemoved(false); data.i_map.clear(); Assert.areEqual(0, data.i_map.size()); setDefaultValues(data.i_map); }
private ObjectSet query(ExtObjectContainer oc, String n) { Query q = oc.query(); q.constrain(CreateIndexFor.class); q.descend("i_name").constrain(n); return q.execute(); }
private void tQueryInts(ExtObjectContainer oc, int expectedZeroSize) { Query q = oc.query(); q.constrain(CreateIndexFor.class); q.descend("i_int").constrain(new Integer(0)); int zeroSize = q.execute().size(); Assert.areEqual(expectedZeroSize, zeroSize); q = oc.query(); q.constrain(CreateIndexFor.class); q.descend("i_int").constrain(new Integer(4)).greater().equal(); tExpectInts(q, new int[] {5, 7}); q = oc.query(); q.constrain(CreateIndexFor.class); q.descend("i_int").constrain(new Integer(4)).greater(); tExpectInts(q, new int[] {5, 7}); q = oc.query(); q.constrain(CreateIndexFor.class); q.descend("i_int").constrain(new Integer(3)).greater(); tExpectInts(q, new int[] {5, 7}); q = oc.query(); q.constrain(CreateIndexFor.class); q.descend("i_int").constrain(new Integer(3)).greater().equal(); tExpectInts(q, new int[] {3, 3, 5, 7}); q = oc.query(); q.constrain(CreateIndexFor.class); q.descend("i_int").constrain(new Integer(2)).greater().equal(); tExpectInts(q, new int[] {2, 3, 3, 5, 7}); q = oc.query(); q = oc.query(); q.constrain(CreateIndexFor.class); q.descend("i_int").constrain(new Integer(2)).greater(); tExpectInts(q, new int[] {3, 3, 5, 7}); q = oc.query(); q.constrain(CreateIndexFor.class); q.descend("i_int").constrain(new Integer(1)).greater().equal(); tExpectInts(q, new int[] {1, 2, 3, 3, 5, 7}); q = oc.query(); q.constrain(CreateIndexFor.class); q.descend("i_int").constrain(new Integer(1)).greater(); tExpectInts(q, new int[] {2, 3, 3, 5, 7}); q = oc.query(); q.constrain(CreateIndexFor.class); q.descend("i_int").constrain(new Integer(4)).smaller(); tExpectInts(q, new int[] {1, 2, 3, 3}, zeroSize); q = oc.query(); q.constrain(CreateIndexFor.class); q.descend("i_int").constrain(new Integer(4)).smaller().equal(); tExpectInts(q, new int[] {1, 2, 3, 3}, zeroSize); q = oc.query(); q.constrain(CreateIndexFor.class); q.descend("i_int").constrain(new Integer(3)).smaller(); tExpectInts(q, new int[] {1, 2}, zeroSize); q = oc.query(); q.constrain(CreateIndexFor.class); q.descend("i_int").constrain(new Integer(3)).smaller().equal(); tExpectInts(q, new int[] {1, 2, 3, 3}, zeroSize); q = oc.query(); q.constrain(CreateIndexFor.class); q.descend("i_int").constrain(new Integer(2)).smaller().equal(); tExpectInts(q, new int[] {1, 2}, zeroSize); q = oc.query(); q = oc.query(); q.constrain(CreateIndexFor.class); q.descend("i_int").constrain(new Integer(2)).smaller(); tExpectInts(q, new int[] {1}, zeroSize); q = oc.query(); q.constrain(CreateIndexFor.class); q.descend("i_int").constrain(new Integer(1)).smaller().equal(); tExpectInts(q, new int[] {1}, zeroSize); q = oc.query(); q.constrain(CreateIndexFor.class); q.descend("i_int").constrain(new Integer(1)).smaller(); tExpectInts(q, new int[] {}, zeroSize); }
public void concQueryCaseInsenstive(ExtObjectContainer oc) { Query q = oc.query(); q.constrain(CaseInsensitiveTestCase.class); q.constrain(new CaseInsensitiveEvaluation("helloworld")); Assert.areEqual(1, q.execute().size()); }
private Object retrieveInstance(ExtObjectContainer client) { Query query = client.query(); query.constrain(_class); query.descend("_isRoot").constrain(new Boolean(true)); return query.execute().next(); }