com.oberasoftware.jasdb.api.session.EntityBag.find java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 List l =new LinkedList()
Collections.emptyList()
new ArrayList()
Smart code suggestions by Tabnine
}

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

Javadoc

Builds a query for document in the storage for multiple queryfields with optional sorting parameters

Popular methods of EntityBag

addEntity
Adds an entity to the bag of entities
getEntities
Execute a query returning all records in the bag with a given max
getEntity
Retrieves a specific entity from the bag
removeEntity
Removes the entity from the bag using the id
updateEntity
Updates an entity in the bag of entities
ensureIndex
Ensures there is an index present on a given field in this bag, will create if not existent, will do
flush
Forcibly flushes all the data in the bag to the storage
getDiskSize
Returns the size on the disk of the entities
getSize
Returns the amount of entities in the bag
persist
Persists the provided entity, if not exists will be created, if already exists it will be updated
removeIndex
Removes the index from the bag

removeIndex

Popular in Java

Updating database using SQL prepared statement
onCreateOptionsMenu (Activity)
addToBackStack (FragmentTransaction)
setContentView (Activity)
Font (java.awt)
The Font class represents fonts, which are used to render text in a visible way. A font provides the
Kernel (java.awt.image)
FileNotFoundException (java.io)
Thrown when a file specified by a program cannot be found.
Map (java.util)
A Map is a data structure consisting of a set of keys and values in which each key is mapped to a si
AtomicInteger (java.util.concurrent.atomic)
An int value that may be updated atomically. See the java.util.concurrent.atomic package specificati
Loader (org.hibernate.loader)
Abstract superclass of object loading (and querying) strategies. This class implements useful common
Top 15 Vim Plugins

How to use findmethodin com.oberasoftware.jasdb.api.session.EntityBag

Best Java code snippets using com.oberasoftware.jasdb.api.session.EntityBag.find (Showing top 20 results out of 315)

How to use
find
method
in
com.oberasoftware.jasdb.api.session.EntityBag