How to use

find

method

in

com.oberasoftware.jasdb.api.session.EntityBag

private List<Entity> getEntities(EntityBag bag, QueryBuilder query, int start, int limit) throws JasDBStorageException {
  QueryExecutor executor = bag.find(query);
  if(start > 0 && limit > 0) {
    executor.paging(start, limit);
  } else if(limit > 0) {
    executor.limit(limit);
  }
  final List<Entity> entities = new ArrayList<>();
  try (QueryResult result = executor.execute()) {
    for (Entity entity : result) {
      entities.add(entity);
    }
  }
  return entities;
}

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 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();
  }
}

@RequestMapping(value = "/{instanceId}/{bag}", method = RequestMethod.POST)
public String searchFieldValue(SearchForm searchForm, @PathVariable String instanceId, @PathVariable String bag, Model model) throws JasDBException {
  DBSession session = sessionFactory.createSession(instanceId);
  EntityBag entityBag = session.getBag(bag);
  PageResult result = new PageResult();
  model.addAttribute("page", result);
  if(entityBag != null) {
    QueryResult queryResult = entityBag.find(QueryBuilder.createBuilder().field(searchForm.getField()).value(searchForm.getValue())).limit(DEFAULT_PAGE_SIZE).execute();
    result.setEntities(loadEntities(queryResult));
  } else {
    result.setMessage(String.format("Unable to load Bag: %s on instance: %s as it does not exist", bag, instanceId));
  }
  return "data/query";
}

  @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 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 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 testMultivaluePagingEqualsOperation() throws Exception {
  DBSession session = sessionFactory.createSession();
  EntityBag bag = session.createOrGetBag("inverted");
  try {
    int start = 0;
    long lage = (long) (MAX_AGE / 2);
    int ageSize = ageAmounts.get(lage);
    int batchSize = ageSize / 4;
    while(start + batchSize <= ageSize) {
      int end = start + batchSize;
      LOG.debug("Starting retrieval of start: {} and end: {} for age: {}", start, end, lage);
      QueryExecutor executor = bag.find(QueryBuilder.createBuilder().field("age").value(lage));
      executor.paging(start, batchSize);
      QueryResult result = executor.execute();
      assertEquals("Unexpected query size", batchSize, result.size());
      for(Entity entity : result) {
        String age = entity.getProperty("age").getFirstValueObject().toString();
        assertEquals("Unexpected age", String.valueOf(MAX_AGE / 2), age);
      }
      start = end;
    }
  } finally {
    session.closeSession();
    JasDBMain.shutdown();
  }
}

@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();
  }
}

@Test
public void testInvalidJsonInsert() throws Exception {
  DBSession session = sessionFactory.createSession();
  EntityBag bag = session.createOrGetBag("MySpecialBag");
  SimpleEntity entity = new SimpleEntity();
  entity.addProperty("title", "Title of my content");
  entity.addProperty("text", "Some big piece of text content");
  bag.addEntity(entity);
  QueryExecutor executor = bag.find(QueryBuilder.createBuilder().field("text").value("Some big piece of text content"));
  QueryResult result = executor.execute();
  assertThat(result.size(), is(1L));
  for(Entity resultEntity : result) {
    String json = SimpleEntity.toJson(resultEntity);
    log.info("Output: {}", json);
  }
}

  @Test
  public void testNoConditionsFullScan() throws Exception {
    DBSession session = sessionFactory.createSession();
    EntityBag bag = session.createOrGetBag("smallbag");
    bag.addEntity(new SimpleEntity(ID1).addProperty("type", "thing"));
    bag.addEntity(new SimpleEntity(ID2).addProperty("type", "thing"));
    bag.addEntity(new SimpleEntity(ID3).addProperty("type", "contribution"));
    bag.addEntity(new SimpleEntity(ID4).addProperty("type", "contribution"));

    try {
      QueryBuilder builder = QueryBuilder.createBuilder();

      QueryExecutor executor = bag.find(builder);
      List<Entity> entities = toList(executor.execute());
      List<String> entityIds = entities.stream().map(Entity::getInternalId).collect(Collectors.toList());

      assertThat(entityIds, hasItems(ID1, ID2, ID3, ID4));
    } finally {
      session.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();
  }
}

  @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 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();
  }
}

/**
 * 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();
  }
}

@Test
public void testSortByNonExistingField() throws Exception {
  DBSession session = sessionFactory.createSession();
  try{
    EntityBag bag = session.createOrGetBag("Bag");
    SimpleEntity entity = new SimpleEntity();
    entity.addProperty("name", "xxx");
    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("_id",Order.DESCENDING).sortBy("id", Order.DESCENDING);
    QueryExecutor executor = bag.find(innerQuery);
    QueryResult result = executor.execute();
    assertThat(result.size(), is(2l));
  } finally {
    JasDBMain.shutdown();
  }
}

@Test
public void testAndOperationMultiQueryBuilderTablescan() throws Exception {
  DBSession pojoDb = sessionFactory.createSession();
  EntityBag bag = pojoDb.createOrGetBag("thosha");
  bag.addEntity(new SimpleEntity(ID1).addProperty("type", "thing"));
  bag.addEntity(new SimpleEntity(ID2).addProperty("type", "thing"));
  bag.addEntity(new SimpleEntity(ID3).addProperty("type", "contribution"));
  bag.addEntity(new SimpleEntity(ID4).addProperty("type", "contribution"));
  try {
    QueryBuilder builder = QueryBuilder.createBuilder(BlockType.AND);
    builder.addQueryBlock(QueryBuilder.createBuilder().field("__ID").value(ID3));
    builder.addQueryBlock(QueryBuilder.createBuilder().field("type").value("contribution"));
    QueryExecutor executor = bag.find(builder);
    List<Entity> entities = toList(executor.execute());
    assertThat(entities.size(), is(1));
  } finally {
    pojoDb.closeSession();
    JasDBMain.shutdown();
  }
}

@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 testKeySpecialCharacters() throws Exception {
  DBSession pojoDb = sessionFactory.createSession();
  EntityBag bag = pojoDb.createOrGetBag("inverted");
  bag.addEntity(new SimpleEntity().addProperty("field1", "coëfficiënt van Poisson"));
  try {
    QueryExecutor executor = bag.find(QueryBuilder.createBuilder().field("field1").value("coëfficiënt van Poisson"));
    QueryResult result = executor.execute();
    assertTrue(result.hasNext());
    Entity entity = result.next();
    assertEquals("coëfficiënt van Poisson", entity.getProperty("field1").getFirstValueObject());
    assertFalse(result.hasNext());
  } finally {
    pojoDb.closeSession();
    JasDBMain.shutdown();
  }
}

@Test
public void testQueryNonExistingProperty() throws Exception {
  DBSession pojoDb = sessionFactory.createSession();
  EntityBag bag = pojoDb.createOrGetBag("thosha");
  bag.addEntity(new SimpleEntity("00005442-4961-c49d-0000-013d73bba1f7").addProperty("type", "thing"));
  bag.addEntity(new SimpleEntity("00005442-4961-c49d-0000-013d73bba1f8").addProperty("type", "thing"));
  bag.addEntity(new SimpleEntity("00005442-4961-c49d-0000-013dad2eefd2").addProperty("type", "contribution"));
  bag.addEntity(new SimpleEntity("00005442-4961-c49d-0000-013dd66f0aed").addProperty("type", "contribution"));
  try {
    QueryBuilder builder = QueryBuilder.createBuilder(BlockType.AND);
    builder.addQueryBlock(QueryBuilder.createBuilder().field("NonExistingProperty").value("00005442-4961-c49d-0000-013dad2eefd2"));
    builder.addQueryBlock(QueryBuilder.createBuilder().field("type").value("contribution"));
    QueryExecutor executor = bag.find(builder);
    try (QueryResult result = executor.execute()) {
      assertThat(result.size(), is(0l));
    }
  } finally {
    pojoDb.closeSession();
    JasDBMain.shutdown();
  }
}