com.oberasoftware.jasdb.api.session.EntityBag.addEntity 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 Map<String, Integer> generateCities(int testSize, EntityBag bag) throws JasDBStorageException {
  Map<String, Integer> cityCounts = new HashMap<>();
  Random rnd = new Random();
  for(int i=0; i<testSize; i++) {
    int cityIdx = rnd.nextInt(cities.length);
    String city = cities[cityIdx];
    SimpleEntity entity = new SimpleEntity();
    entity.addProperty("city", city);
    entity.addProperty("itemId", (long)i);
    changeCityCount(city, cityCounts, true);
    bag.addEntity(entity);
  }
  return cityCounts;
}

@RequestMapping(value = "/{instanceId}/createEntity", method = RequestMethod.POST)
public String createData(@Valid WebEntity entity, @PathVariable String instanceId) throws JasDBException {
  DBSession session = sessionFactory.createSession(instanceId);
  EntityBag entityBag = session.createOrGetBag(entity.getBag());
  entityBag.addEntity(SimpleEntity.fromJson(entity.getData()));
  return "redirect:/data/";
}

  public static void main(String[] args) {
    try {
      LOG.info("Starting JasDB");
      JasDBMain.start();

      LOG.info("JasDB was started, awaiting termination signal");

      DBSession session = new LocalDBSession();
      EntityBag bag = session.createOrGetBag("test");
      bag.addEntity(new SimpleEntity().addProperty("testProperty", "someValue"));

      JasDBMain.waitForShutdown();
      LOG.info("JasDB was terminated");
    } catch (JasDBException e) {
      LOG.error("Could not start JasDB", e);
    }
  }
}

  @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 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 testEnsureAndRemoveIndex() throws JasDBException {
  DBSession session = sessionFactory.createSession();
  EntityBag bag = session.createOrGetBag("testbag");
  bag.ensureIndex(new SimpleIndexField("field1", new StringKeyType()), true);
  bag.ensureIndex(new SimpleIndexField("field2", new StringKeyType()), false);
  bag.addEntity(new SimpleEntity().addProperty("field1", "value1").addProperty("field2", "testkey2value"));
  String jasdbHome = storageLocation + "/.jasdb";
  File field1Index = new File(jasdbHome, "testbag_field1.idx");
  File field2Index = new File(jasdbHome, "testbag_field2ID.idx");
  assertTrue("Index 1 file should exist", field1Index.exists());
  assertTrue("Index 2 file should exist", field2Index.exists());
  bag.removeIndex("field1");
  assertFalse("Index 1 file should no longer exist", field1Index.exists());
  assertTrue("Index 2 file should exist", field2Index.exists());
  bag.removeIndex("field2ID");
  assertFalse("Index 1 file should no longer exist", field1Index.exists());
  assertFalse("Index 2 file should no longer exist", field2Index.exists());
}

  @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 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 testBagFlush() throws JasDBException {
  DBSession session = sessionFactory.createSession();
  EntityBag bag = session.createOrGetBag("testbag");
  long sizeBefore = bag.getDiskSize();
  int TEST_SIZE = 1000;
  for(int i=0; i<TEST_SIZE; i++) {
    bag.addEntity(new SimpleEntity());
  }
  bag.flush();
  assertTrue(bag.getDiskSize() > sizeBefore);
}

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

@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 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 testPersistFindPerformance() throws Exception {
  DBSession pojoDb = sessionFactory.createSession();
  EntityBag bag = pojoDb.createOrGetBag("mybag");
  List<String> entityIds = new ArrayList<>();
  for(int i=0; i<NUMBER_ENTITIES; i++) {
    SimpleEntity entity = new SimpleEntity(UUID.randomUUID().toString());
    entity.addProperty("someProperty" + i, i);
    entity.addProperty("doubleId", entity.getInternalId());
    bag.addEntity(entity);
    entityIds.add(entity.getInternalId());
  }
  try {
    for(String id : entityIds) {
      Entity entity = bag.getEntity(id);
      Assert.assertNotNull("Entity for id: " + id + " should be found", entity);
      assertEquals("Id should match expected id", id, entity.getInternalId());
      Assert.assertNotNull("There should be a property doubleId", entity.getProperty("doubleId"));
      assertEquals("Property doubleId should match expected id", id, entity.getProperty("doubleId").getFirstValueObject());
    }
  } finally {
    JasDBMain.shutdown();
  }
}

@Override
public Entity persist(Object persistableObject) throws JasDBStorageException {
  MapResult mappedResult = ENTITY_MAPPER.mapTo(persistableObject);
  String bagName = mappedResult.getBagName();
  EntityBag bag = session.createOrGetBag(bagName);
  Entity persistedEntity;
  try {
    Entity entity = mappedResult.getJasDBEntity();
    if(StringUtils.stringNotEmpty(entity.getInternalId()) && bag.getEntity(entity.getInternalId()) != null) {
      //update
      persistedEntity = bag.updateEntity(mappedResult.getJasDBEntity());
      LOG.debug("Updated entity: {} in bag: {}", persistedEntity, bagName);
    } else {
      persistedEntity = bag.addEntity(mappedResult.getJasDBEntity());
      LOG.debug("Created entity: {} in bag: {}", persistedEntity, bagName);
    }
  } catch(RuntimeJasDBException e) {
    //we do this in case we have exactly two threads at same time trying to persist
    persistedEntity = bag.updateEntity(mappedResult.getJasDBEntity());
    LOG.debug("Updated entity: {} in bag: {}", persistedEntity, bagName);
  }
  //update the ID of the passed object
  ENTITY_MAPPER.updateId(persistedEntity.getInternalId(), persistableObject);
  return persistedEntity;
}

@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 testDeleteEmptyIndexValue() throws Exception {
  try {
    DBSession session = sessionFactory.createSession();
    EntityBag bag = session.createOrGetBag("somebag");
    bag.ensureIndex(new SimpleIndexField("field", new StringKeyType()), false);
    String id = bag.addEntity(new SimpleEntity().addProperty("anotherfield", "somevalue")).getInternalId();
    bag.removeEntity(id);
  } finally {
    JasDBMain.shutdown();
  }
}

@Test
public void testNotEqualsMultiIndexes() throws Exception {
  try {
    DBSession session = sessionFactory.createSession();
    EntityBag bag = session.createOrGetBag("websites");
    bag.ensureIndex(new SimpleIndexField("url", new StringKeyType()), false);
    bag.ensureIndex(
        new SimpleCompositeIndexField(
            new SimpleIndexField("stepid", new StringKeyType()),
            new SimpleIndexField("workflow", new LongKeyType())
        ),false);
    bag.addEntity(new SimpleEntity().addProperty("url", "").addProperty("stepid", 1L).addProperty("workflow", 1L));
    bag.addEntity(new SimpleEntity().addProperty("url", "").addProperty("stepid", 1L).addProperty("workflow", 1L));
    bag.addEntity(new SimpleEntity().addProperty("url", "").addProperty("stepid", 1L).addProperty("workflow", 1L));
    bag.addEntity(new SimpleEntity().addProperty("url", "http://someurl.nl/1").addProperty("stepid", 1L).addProperty("workflow", 1L));
    bag.addEntity(new SimpleEntity().addProperty("url", "http://someurl.nl/2").addProperty("stepid", 1L).addProperty("workflow", 1L));
    QueryResult r = bag.find(QueryBuilder.createBuilder()
        .field("stepid").value(1L)
        .field("workflow").value(1L)
        .field("url").notEquals("")).execute();
    assertThat(r.size(), is(2L));
  } finally {
    JasDBMain.shutdown();
  }
}

@Test
public void testPersistMultiValue() throws Exception {
  DBSession session = sessionFactory.createSession();
  EntityBag bag = session.createOrGetBag("testbag");
  try {
    Entity entity = new SimpleEntity();
    entity.addProperty("field1", "value1");
    entity.addProperty("field1", "value2");
    entity.addProperty("field1", "value3");
    entity.addProperty("number", 100L);
    entity.addProperty("number", 500L);
    bag.addEntity(entity);
    String entityId = entity.getInternalId();
    entity = bag.getEntity(entityId);
    Property property = entity.getProperty("field1");
    Assert.assertNotNull(property);
    assertEquals("The object should be multivalue", true, property.isMultiValue());
    assertEquals("There should be three properties", 3, property.getValues().size());
    assertEquals("Unexpected value", "value1", property.getValues().get(0).getValue());
    assertEquals("Unexpected value", "value2", property.getValues().get(1).getValue());
    assertEquals("Unexpected value", "value3", property.getValues().get(2).getValue());
    property = entity.getProperty("number");
    assertEquals("The object should be multivalue", true, property.isMultiValue());
    assertEquals("There should be three properties", 2, property.getValues().size());
    assertEquals("Unexpected value", 100L, property.getValues().get(0).getValue());
    assertEquals("Unexpected value", 500L, property.getValues().get(1).getValue());
  } finally {
    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 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());
  }
}

Javadoc

Adds an entity to the bag of entities

Popular methods of EntityBag

find
Builds a query for document in the storage for a specific queryfield with optional sorting parameter
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

Reading from database using SQL prepared statement
addToBackStack (FragmentTransaction)
getSupportFragmentManager (FragmentActivity)
getApplicationContext (Context)
URLEncoder (java.net)
This class is used to encode a string using the format required by application/x-www-form-urlencoded
UnknownHostException (java.net)
Thrown when a hostname can not be resolved.
Random (java.util)
This class provides methods that return pseudo-random values.It is dangerous to seed Random with the
BlockingQueue (java.util.concurrent)
A java.util.Queue that additionally supports operations that wait for the queue to become non-empty
ConcurrentHashMap (java.util.concurrent)
A plug-in replacement for JDK1.5 java.util.concurrent.ConcurrentHashMap. This version is based on or
IOUtils (org.apache.commons.io)
General IO stream manipulation utilities. This class provides static utility methods for input/outpu
14 Best Plugins for Eclipse

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

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

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