public StreamableEntityCollection(QueryResult result) { this.result = result; this.size = result.size(); }
List<Entity> toList(QueryResult result) { List<Entity> entities = new ArrayList<>(); result.forEach(entities::add); return entities; }
List<String> assertResult(int start, int amount, QueryResult result) { List<String> keysFoundInOrder = new ArrayList<>(); for(int i=start; i<(start + amount) && result.hasNext(); i++) { Entity entity = result.next(); String expectedId = longToId.get((long) i); assertNotNull("There should be a returned entity", entity); assertEquals("The id's should match", expectedId, entity.getInternalId()); Property property = entity.getProperty("field1"); assertNotNull("Property should be set", property); assertTrue("Property should be String", property.getFirstValueObject() instanceof String); assertEquals("Property value should match", "value" + i, property.getFirstValueObject()); keysFoundInOrder.add(entity.getInternalId()); } return keysFoundInOrder; }
@Test public void testCreateAndInsertEntities() throws JasDBException, IOException { DBSession session = sessionFactory.createSession(); session.addInstance(MY_INSTANCE); EntityBag bag = session.createOrGetBag(MY_INSTANCE, BAG_1); bag.addEntity(new SimpleEntity().addProperty("test", "value")); QueryResult result = bag.getEntities(); assertThat(result.size(), is(1l)); Entity entity = result.next(); assertThat(entity, notNullValue()); assertThat(entity.getProperty("test").getFirstValue().toString(), is("value")); }
@Test public void testRangeQuery() throws Exception { DBSession pojoDb = sessionFactory.createSession(); EntityBag bag = pojoDb.createOrGetBag("inverted"); try { QueryExecutor executor = bag.find(QueryBuilder.createBuilder().field("field5").greaterThan(10).field("field5").smallerThan(30)); try (QueryResult result = executor.execute()) { assertEquals(19, result.size()); assertNotNull(result); assertTrue("There should be a result", result.hasNext()); assertResult(11, 18, result); } } finally { pojoDb.closeSession(); JasDBMain.shutdown(); } }
@Test public void testPersistIndexNonUniqueQuery() throws JasDBException, InterruptedException { DBSession session = sessionFactory.createSession(); EntityBag bag = session.createOrGetBag("testbag"); bag.addEntity(new SimpleEntity().addProperty("city", "Amsterdam")); bag.addEntity(new SimpleEntity().addProperty("city", "Amsterdam")); bag.addEntity(new SimpleEntity().addProperty("city", "Rotterdam")); bag.addEntity(new SimpleEntity().addProperty("city", "Utrecht")); bag.addEntity(new SimpleEntity().addProperty("city", "Utrecht")); QueryResult result = bag.find(QueryBuilder.createBuilder().field("city").value("Amsterdam")).execute(); assertThat(result.size(), is(2L)); result.close(); bag.ensureIndex(new SimpleIndexField("city", new StringKeyType()), false); //let's give the index some time to build Thread.sleep(5000); result = bag.find(QueryBuilder.createBuilder().field("city").value("Amsterdam")).execute(); assertThat(result.size(), is(2L)); result.close(); } }
@Test public void testEqualsAndQueryExclude() throws Exception { DBSession pojoDb = sessionFactory.createSession(); EntityBag bag = pojoDb.createOrGetBag("inverted"); try { String queryKey1 = "value1"; String queryKey2 = "value50"; QueryExecutor executor = bag.find(QueryBuilder.createBuilder().field("field1").value(queryKey1).field("field1").value(queryKey2)); long start = System.nanoTime(); QueryResult result = executor.execute(); long end = System.nanoTime(); long passed = end - start; LOG.info("Query execution took: {}", passed); assertNotNull(result); Assert.assertFalse("There should not be a result", result.hasNext()); } finally { pojoDb.closeSession(); JasDBMain.shutdown(); } }
@Test public void testSortDescendingInvalidType() throws Exception { DBSession session = sessionFactory.createSession(); try{ EntityBag bag = session.createOrGetBag("Bag"); SimpleEntity entity = new SimpleEntity(); entity.addProperty("name", "xxx"); entity.addProperty("v", "3"); bag.addEntity(entity); entity = new SimpleEntity(); entity.addProperty("name", 1); entity.addProperty("v", "1"); bag.addEntity(entity); entity = new SimpleEntity(); entity.addProperty("name", "xxx"); entity.addProperty("v", "2"); bag.addEntity(entity); QueryBuilder innerQuery = QueryBuilder.createBuilder(); innerQuery.field("name").value("xxx").sortBy("v", Order.DESCENDING); QueryExecutor executor = bag.find(innerQuery); QueryResult result = executor.execute(); assertThat(result.size(), is(2l)); assertThat(result.next().getValue("v"), is("3")); assertThat(result.next().getValue("v"), is("2")); } finally { JasDBMain.shutdown(); } }
@Test public void testPersisterRemove() throws Exception { int testSize = 1000; DBSession session = sessionFactory.createSession(); EntityBag bag = session.createOrGetBag("testbag"); bag.ensureIndex(new SimpleIndexField("city", new StringKeyType(100)), false); bag.ensureIndex(new SimpleIndexField("testField", new LongKeyType()), true); Random rnd = new Random(); for(int i=0; i<testSize; i++) { int cityIdx = rnd.nextInt(SimpleBaseTest.possibleCities.length); String city = SimpleBaseTest.possibleCities[cityIdx]; SimpleEntity entity = new SimpleEntity(); entity.addProperty("city", city); entity.addProperty("testField", (long)i); bag.addEntity(entity); } for(String city : SimpleBaseTest.possibleCities) { QueryResult result = bag.find(QueryBuilder.createBuilder().field("city").value(city)).execute(); for(Entity foundEntity : result) { Long testFieldValue = foundEntity.getProperty("testField").getFirstValueObject(); bag.removeEntity(foundEntity); assertFalse("There should no longer be a result", bag.find(QueryBuilder.createBuilder().field("testField").value(testFieldValue)).execute().hasNext()); } result = bag.find(QueryBuilder.createBuilder().field("city").value(city)).execute(); assertEquals("There should no longer be any entity", (long) 0, result.size()); } }
@Test public void testRangeQuerySortByOtherFieldNaturalOrdering() throws Exception { DBSession pojoDb = sessionFactory.createSession(); EntityBag bag = pojoDb.createOrGetBag("inverted"); try { QueryExecutor executor = bag.find(QueryBuilder.createBuilder().field("field5").greaterThan(10).field("field5").smallerThan(30).sortBy("field1")); try (QueryResult result = executor.execute()) { assertNotNull(result); assertTrue("There should be a result", result.hasNext()); int start = 11; int amount = 18; List<String> keysInOrder = assertResult(start, amount, result); List<String> expectedOrder = new ArrayList<>(); for (int i = start; i < amount + start; i++) { String id = valueToId.get("value" + i); expectedOrder.add(id); LOG.info("Expected key: {} with value: {}", id, "value" + i); } assertListOrder(keysInOrder, expectedOrder); } } finally { pojoDb.closeSession(); JasDBMain.shutdown(); } }
private void assertCityIndexes(EntityBag bag, String[] cities, Map<String, Integer> expectedCounts) throws Exception { for(String city : cities) { QueryResult r = bag.find(QueryBuilder.createBuilder().field("city").value(city)).execute(); int expectedCount = expectedCounts.get(city); assertEquals("Counts are unexpected for city: " + city, expectedCount, r.size()); } }
@Test public void testEqualsTablescan() throws Exception { DBSession pojoDb = sessionFactory.createSession(); EntityBag bag = pojoDb.createOrGetBag("inverted"); try { /* we get the entity expected, by using the value on field5 which is the same ordering */ String queryKey1 = "value50"; String expectedId1 = valueToId.get(queryKey1); QueryExecutor executor = bag.find(QueryBuilder.createBuilder().field("field7").value("myValue50")); long start = System.nanoTime(); QueryResult result = executor.execute(); long end = System.nanoTime(); long passed = end - start; LOG.info("Query execution took: {}", passed); assertNotNull(result); assertTrue("There should be a result", result.hasNext()); Entity entity = result.next(); assertNotNull("There should be a returned entity", entity); assertEquals("The id's should match", expectedId1, entity.getInternalId()); Assert.assertFalse("There should no longer be a result", result.hasNext()); } finally { pojoDb.closeSession(); JasDBMain.shutdown(); } }
@Test public void testEqualsOutofRange() throws Exception { DBSession pojoDb = sessionFactory.createSession(); EntityBag bag = pojoDb.createOrGetBag("inverted"); try { for(String city : SimpleBaseTest.possibleCities) { QueryExecutor executor = bag.find(QueryBuilder.createBuilder().field("city").value(city)); executor.paging(NUMBER_ENTITIES, 1000); try (QueryResult result = executor.execute()) { Assert.assertFalse("There should be no result", result.hasNext()); } } } finally { pojoDb.closeSession(); JasDBMain.shutdown(); } }
@Test public void testNotEqualsAge() throws Exception { DBSession pojoDb = sessionFactory.createSession(); EntityBag bag = pojoDb.createOrGetBag("inverted"); try { for(int age = 0; age < MAX_AGE; age++) { QueryExecutor executor = bag.find(QueryBuilder.createBuilder().field("age").notEquals(age)); long start = System.nanoTime(); long end = System.nanoTime(); long passed = end - start; LOG.info("Query execution took: {}", passed); try (QueryResult result = executor.execute()) { int expected = NUMBER_ENTITIES - ageAmounts.get((long) age); for (Entity entity : result) { assertThat(entity.getValue("age").toString(), not(equalTo(String.valueOf(age)))); } assertThat(result.size(), is((long) expected)); } } } finally { pojoDb.closeSession(); JasDBMain.shutdown(); } }
@Test public void testEqualsTablescanMultiFields() throws Exception { DBSession pojoDb = sessionFactory.createSession(); EntityBag bag = pojoDb.createOrGetBag("inverted"); try { /* we get the entity expected, by using the value on field5 which is the same ordering */ String queryKey1 = "value50"; String expectedId1 = valueToId.get(queryKey1); QueryExecutor executor = bag.find(QueryBuilder.createBuilder().field("field7").value("myValue50").field("field8").value("myValue50")); long start = System.nanoTime(); QueryResult result = executor.execute(); long end = System.nanoTime(); long passed = end - start; LOG.info("Query execution took: {}", passed); assertNotNull(result); assertTrue("There should be a result", result.hasNext()); Entity entity = result.next(); assertNotNull("There should be a returned entity", entity); assertEquals("The id's should match", expectedId1, entity.getInternalId()); Assert.assertFalse("There should no longer be a result", result.hasNext()); } finally { pojoDb.closeSession(); JasDBMain.shutdown(); } }
/** * Simply test if we can query with an empty string key */ @Test public void testEmptyStringKey() throws Exception { DBSession pojoDb = sessionFactory.createSession(); EntityBag bag = pojoDb.createOrGetBag("inverted"); try { QueryExecutor executor = bag.find(QueryBuilder.createBuilder().field("field1").value("")); try (QueryResult result = executor.execute()) { assertNotNull(result); Assert.assertFalse("There should not be a result", result.hasNext()); } } finally { pojoDb.closeSession(); JasDBMain.shutdown(); } }
@Override public <T> List<T> findEntities(Class<T> types, QueryBuilder builder, int start, int limit) throws JasDBStorageException { List<T> entities = new ArrayList<>(); EntityMetadata entityMetadata = ENTITY_MAPPER.getEntityMetadata(types); EntityBag bag = session.getBag(entityMetadata.getBagName()); if(bag != null) { QueryExecutor executor = bag.find(builder); if(start > 0 && limit > 0) { executor.paging(start, limit); } else if(limit > 0) { executor.limit(limit); } QueryResult result = executor.execute(); LOG.debug("Executing Query: {} results: {}", builder, result.size()); for(Entity entity : result) { entities.add(ENTITY_MAPPER.mapFrom(types, entity)); } } return entities; } }
@Test public void testEqualsPartialTablescanMultiFields() throws Exception { DBSession pojoDb = sessionFactory.createSession(); EntityBag bag = pojoDb.createOrGetBag("inverted"); try { /* we get the entity expected, by using the value on field5 which is the same ordering */ String queryKey1 = "value50"; String expectedId1 = valueToId.get(queryKey1); QueryExecutor executor = bag.find(QueryBuilder.createBuilder().field("field7").value("myValue50").field("field1").value("value50")); long start = System.nanoTime(); QueryResult result = executor.execute(); long end = System.nanoTime(); long passed = end - start; LOG.info("Query execution took: {}", passed); assertNotNull(result); assertTrue("There should be a result", result.hasNext()); Entity entity = result.next(); assertNotNull("There should be a returned entity", entity); assertEquals("The id's should match", expectedId1, entity.getInternalId()); Assert.assertFalse("There should no longer be a result", result.hasNext()); } finally { pojoDb.closeSession(); JasDBMain.shutdown(); } }
@Test public void testEqualsAgeWithLimiting() throws Exception { DBSession pojoDb = sessionFactory.createSession(); EntityBag bag = pojoDb.createOrGetBag("inverted"); try { int limit = 3; Integer maxAmount = ageAmounts.get((long) 20); assertTrue(maxAmount > 5); QueryExecutor executor = bag.find(QueryBuilder.createBuilder().field("age").value(20)); executor.limit(limit); long start = System.nanoTime(); QueryResult result = executor.execute(); long end = System.nanoTime(); long passed = (end - start); LOG.info("Age query took: {} with: {} results", passed, result.size()); List<Entity> entities = aggregateResult(result); assertEquals("There should only be three results", limit, entities.size()); } finally { pojoDb.closeSession(); JasDBMain.shutdown(); } }
@Test public void testEqualsOrQuery() throws Exception { DBSession pojoDb = sessionFactory.createSession(); EntityBag bag = pojoDb.createOrGetBag("inverted"); try { String queryKey1 = "value1"; String queryKey2 = "value50"; String expectedId1 = valueToId.get(queryKey1); String expectedId2 = valueToId.get(queryKey2); QueryExecutor executor = bag.find(QueryBuilder.createBuilder().field("field1").value(queryKey1) .or(QueryBuilder.createBuilder().field("field1").value(queryKey2)).sortBy("field1")); long start = System.nanoTime(); QueryResult result = executor.execute(); long end = System.nanoTime(); long passed = end - start; LOG.info("Query execution took: {}", passed); assertNotNull(result); assertTrue("There should be a result", result.hasNext()); Entity entity1 = result.next(); assertTrue("There should be a result", result.hasNext()); Entity entity2 = result.next(); assertNotNull("There should be a returned entity", entity1); assertEquals("The id's should match", expectedId1, entity1.getInternalId()); assertNotNull("There should be a returned entity", entity2); assertEquals("The id's should match", expectedId2, entity2.getInternalId()); } finally { pojoDb.closeSession(); JasDBMain.shutdown(); } }