コード例 #1
0
  @Test
  public void testKeywordsAndQuery() throws Exception {
    logger.info("testKeywordsOrQuery");

    UUID applicationId = createApplication("testOrganization", "testKeywordsAndQuery");
    assertNotNull(applicationId);

    EntityManager em = emf.getEntityManager(applicationId);
    assertNotNull(em);

    Map<String, Object> properties = new LinkedHashMap<String, Object>();
    properties.put("title", "Galactians 2");
    properties.put("keywords", "Hot, Space Invaders, Classic");
    Entity firstGame = em.create("game", properties);

    properties = new LinkedHashMap<String, Object>();
    properties.put("title", "Bunnies Extreme");
    properties.put("keywords", "Hot, New");
    Entity secondGame = em.create("game", properties);

    properties = new LinkedHashMap<String, Object>();
    properties.put("title", "Hot Shots Extreme");
    properties.put("keywords", "Action, New");
    Entity thirdGame = em.create("game", properties);

    Query query =
        Query.fromQL("select * where keywords contains 'new' and title contains 'extreme'");
    Results r = em.searchCollection(em.getApplicationRef(), "games", query);
    logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));
    assertEquals(2, r.size());

    assertEquals(secondGame.getUuid(), r.getEntities().get(0).getUuid());
    assertEquals(thirdGame.getUuid(), r.getEntities().get(1).getUuid());
  }
コード例 #2
0
  @Test
  public void testSecondarySorts() throws Exception {
    logger.info("testSecondarySorts");

    UUID applicationId = createApplication("testOrganization", "testSecondarySorts");
    assertNotNull(applicationId);

    EntityManager em = emf.getEntityManager(applicationId);
    assertNotNull(em);

    for (int i = alphabet.length - 1; i >= 0; i--) {
      String name = alphabet[i];
      Map<String, Object> properties = new LinkedHashMap<String, Object>();
      properties.put("name", name);
      properties.put("group", i / 3);
      properties.put("reverse_name", alphabet[alphabet.length - 1 - i]);

      em.create("item", properties);
    }

    Query query = Query.fromQL("group = 1 order by name desc");
    Results r = em.searchCollection(em.getApplicationRef(), "items", query);
    logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));
    int i = 6;
    for (Entity entity : r.getEntities()) {
      i--;
      assertEquals(1L, entity.getProperty("group"));
      assertEquals(alphabet[i], entity.getProperty("name"));
    }
    assertEquals(3, i);
  }
コード例 #3
0
  @Test
  public void userFirstNameSearch() throws Exception {
    UUID applicationId = createApplication("testOrganization", "testFirstName");
    assertNotNull(applicationId);

    EntityManager em = emf.getEntityManager(applicationId);
    assertNotNull(em);

    String firstName = "firstName" + UUIDUtils.newTimeUUID();

    Map<String, Object> properties = new LinkedHashMap<String, Object>();
    properties.put("username", "edanuff");
    properties.put("email", "*****@*****.**");
    properties.put("firstname", firstName);

    Entity user = em.create("user", properties);
    assertNotNull(user);

    // EntityRef
    Query query = new Query();
    query.addEqualityFilter("firstname", firstName);

    Results r = em.searchCollection(em.getApplicationRef(), "users", query);

    assertTrue(r.size() > 0);

    Entity returned = r.getEntities().get(0);

    assertEquals(user.getUuid(), returned.getUuid());

    // update the username
    String newFirstName = "firstName" + UUIDUtils.newTimeUUID();

    user.setProperty("firstname", newFirstName);

    em.update(user);

    // search with the old username, should be no results
    query = new Query();
    query.addEqualityFilter("firstname", firstName);

    r = em.searchCollection(em.getApplicationRef(), "users", query);

    assertEquals(0, r.size());

    // search with the new username, should be results.

    query = new Query();
    query.addEqualityFilter("firstname", newFirstName);

    r = em.searchCollection(em.getApplicationRef(), "users", query);

    assertTrue(r.size() > 0);

    returned = r.getEntities().get(0);

    assertEquals(user.getUuid(), returned.getUuid());
  }
コード例 #4
0
  @Test
  public void andQuery() throws Exception {
    UUID applicationId = createApplication("testOrganization", "andQuery");
    assertNotNull(applicationId);

    EntityManager em = emf.getEntityManager(applicationId);
    assertNotNull(em);

    Map<String, Object> properties = new LinkedHashMap<String, Object>();
    properties.put("keywords", "blah,test,game");
    properties.put("title", "Solitaire");

    Entity game1 = em.create("game", properties);
    assertNotNull(game1);

    properties = new LinkedHashMap<String, Object>();
    properties.put("keywords", "random,test");
    properties.put("title", "Hearts");

    Entity game2 = em.create("game", properties);
    assertNotNull(game2);

    // overlap
    Query query =
        Query.fromQL("select * where keywords contains 'test' AND keywords contains 'random'");
    Results r = em.searchCollection(em.getApplicationRef(), "games", query);
    assertEquals(1, r.size());

    // disjoint
    query = Query.fromQL("select * where keywords contains 'random' AND keywords contains 'blah'");
    r = em.searchCollection(em.getApplicationRef(), "games", query);
    assertEquals(0, r.size());

    // same each side
    query = Query.fromQL("select * where keywords contains 'test' AND keywords contains 'test'");
    r = em.searchCollection(em.getApplicationRef(), "games", query);
    assertEquals(2, r.size());

    Entity returned = r.getEntities().get(0);
    assertEquals(game1.getUuid(), returned.getUuid());

    returned = r.getEntities().get(1);
    assertEquals(game2.getUuid(), returned.getUuid());

    // one side, left
    query = Query.fromQL("select * where keywords contains 'test' AND keywords contains 'foobar'");
    r = em.searchCollection(em.getApplicationRef(), "games", query);
    assertEquals(0, r.size());

    // one side, right
    query = Query.fromQL("select * where keywords contains 'foobar' AND keywords contains 'test'");
    r = em.searchCollection(em.getApplicationRef(), "games", query);
    assertEquals(0, r.size());
  }
コード例 #5
0
  @Test
  public void pagingWithBoundsCriteria() throws Exception {

    UUID applicationId = createApplication("testOrganization", "pagingWithBoundsCriteria");
    assertNotNull(applicationId);

    EntityManager em = emf.getEntityManager(applicationId);
    assertNotNull(em);

    int size = 40;
    List<UUID> entityIds = new ArrayList<UUID>();

    for (int i = 0; i < size; i++) {
      Map<String, Object> properties = new LinkedHashMap<String, Object>();
      properties.put("index", i);
      Entity created = em.create("page", properties);

      entityIds.add(created.getUuid());
    }

    int pageSize = 10;

    Query query = new Query();
    query.setLimit(pageSize);
    query.addFilter("index >= 10");
    query.addFilter("index <= 29");

    Results r = null;

    // check they're all the same before deletion
    for (int i = 1; i < 3; i++) {

      r = em.searchCollection(em.getApplicationRef(), "pages", query);

      logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));

      assertEquals(pageSize, r.size());

      for (int j = 0; j < pageSize; j++) {
        assertEquals(entityIds.get(i * pageSize + j), r.getEntities().get(j).getUuid());
      }

      query.setCursor(r.getCursor());
    }

    r = em.searchCollection(em.getApplicationRef(), "pages", query);

    assertEquals(0, r.size());

    assertNull(r.getCursor());
  }
コード例 #6
0
  @Test
  public void groupTitleSearch() throws Exception {
    UUID applicationId = createApplication("testOrganization", "groupTitleSearch");
    assertNotNull(applicationId);

    EntityManager em = emf.getEntityManager(applicationId);
    assertNotNull(em);

    String titleName = "groupName" + UUIDUtils.newTimeUUID();

    Map<String, Object> properties = new LinkedHashMap<String, Object>();
    properties.put("title", titleName);
    properties.put("path", "testPath");
    properties.put("name", "testName");

    Entity group = em.create("group", properties);
    assertNotNull(group);

    // EntityRef
    Query query = new Query();
    query.addEqualityFilter("title", titleName);

    Results r = em.searchCollection(em.getApplicationRef(), "groups", query);

    assertTrue(r.size() > 0);

    Entity returned = r.getEntities().get(0);

    assertEquals(group.getUuid(), returned.getUuid());
  }
コード例 #7
0
  @Test
  public void userLastNameSearch() throws Exception {
    UUID applicationId = createApplication("testOrganization", "testLastName");
    assertNotNull(applicationId);

    EntityManager em = emf.getEntityManager(applicationId);
    assertNotNull(em);

    String lastName = "lastName" + UUIDUtils.newTimeUUID();

    Map<String, Object> properties = new LinkedHashMap<String, Object>();
    properties.put("username", "edanuff");
    properties.put("email", "*****@*****.**");
    properties.put("lastname", lastName);

    Entity user = em.create("user", properties);
    assertNotNull(user);

    // EntityRef
    Query query = new Query();
    query.addEqualityFilter("lastname", lastName);

    Results r = em.searchCollection(em.getApplicationRef(), "users", query);

    assertTrue(r.size() > 0);

    Entity returned = r.getEntities().get(0);

    assertEquals(user.getUuid(), returned.getUuid());
  }
コード例 #8
0
  @Test
  public void testNotQueryAnd() throws Exception {

    UUID applicationId = createApplication("testOrganization", "testNotQueryAnd");

    EntityManager em = emf.getEntityManager(applicationId);

    Map<String, Object> location = new LinkedHashMap<String, Object>();
    location.put("Place", "24 Westminster Avenue, Venice, CA 90291, USA");
    location.put("Longitude", -118.47425979999998);
    location.put("Latitude", 33.9887663);

    Map<String, Object> recipient = new LinkedHashMap<String, Object>();
    recipient.put("TimeRequested", 1359077878l);
    recipient.put("Username", "fb_536692245");
    recipient.put("Location", location);

    Map<String, Object> properties = new LinkedHashMap<String, Object>();
    properties.put("Flag", "requested");
    properties.put("Recipient", recipient);

    em.create("loveobject", properties);

    location = new LinkedHashMap<String, Object>();
    location.put(
        "Place",
        "Via Pietro Maroncelli, 48, 62012 Santa Maria Apparente Province of Macerata, Italy");
    location.put("Longitude", 13.693080199999999);
    location.put("Latitude", 43.2985019);

    recipient = new LinkedHashMap<String, Object>();
    recipient.put("TimeRequested", 1359077878l);
    recipient.put("Username", "fb_100000787138041");
    recipient.put("Location", location);

    properties = new LinkedHashMap<String, Object>();
    properties.put("Flag", "requested");
    properties.put("Recipient", recipient);

    em.create("loveobject", properties);

    // String s = "select * where Flag = 'requested'";
    // String s =
    // "select * where Flag = 'requested' and NOT Recipient.Username = '******' order by
    // created asc";
    String s =
        "select * where Flag = 'requested' and NOT Recipient.Username = '******' order by created asc";
    Query query = Query.fromQL(s);

    Results r = em.searchCollection(em.getApplicationRef(), "loveobjects", query);
    assertTrue(r.size() == 1);

    String username =
        (String) ((Map) r.getEntities().get(0).getProperty("Recipient")).get("Username");
    // selection results should be a list of lists
    List<Object> sr = query.getSelectionResults(r);
    assertTrue(sr.size() == 1);

    assertEquals("fb_100000787138041", username);
  }
コード例 #9
0
  @Test
  public void emptyQueryReverse() throws Exception {
    UUID applicationId = createApplication("testOrganization", "testEmptyQueryReverse");
    assertNotNull(applicationId);

    EntityManager em = emf.getEntityManager(applicationId);
    assertNotNull(em);

    String firstName = "firstName" + UUIDUtils.newTimeUUID();

    Map<String, Object> properties = new LinkedHashMap<String, Object>();
    properties.put("username", "edanuff");
    properties.put("email", "*****@*****.**");
    properties.put("firstname", firstName);

    Entity user = em.create("user", properties);
    assertNotNull(user);

    properties = new LinkedHashMap<String, Object>();
    properties.put("username", "djacobs");
    properties.put("email", "*****@*****.**");

    Entity user2 = em.create("user", properties);
    assertNotNull(user2);

    // EntityRef
    Query query = new Query();
    query.setReversed(true);

    Results r = em.searchCollection(em.getApplicationRef(), "users", query);

    assertEquals(2, r.size());

    Entity returned = r.getEntities().get(0);

    assertEquals(user2.getUuid(), returned.getUuid());

    returned = r.getEntities().get(1);

    assertEquals(user.getUuid(), returned.getUuid());
  }
コード例 #10
0
  @Test
  public void runtimeTypeCorrect() throws Exception {

    UUID applicationId = createApplication("testOrganization", "runtimeTypeCorrect");
    assertNotNull(applicationId);

    EntityManager em = emf.getEntityManager(applicationId);
    assertNotNull(em);

    int size = 20;
    List<User> createdEntities = new ArrayList<User>();

    for (int i = 0; i < size; i++) {
      User user = new User();
      user.setEmail(String.format("*****@*****.**", i));
      user.setUsername(String.format("test%d", i));
      user.setName(String.format("test%d", i));

      User created = em.create(user);

      createdEntities.add(created);
    }

    Results r =
        em.getCollection(em.getApplicationRef(), "users", null, 50, Level.ALL_PROPERTIES, false);

    logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));

    assertEquals(size, r.size());

    // check they're all the same before deletion
    for (int i = 0; i < size; i++) {
      assertEquals(createdEntities.get(i).getUuid(), r.getEntities().get(i).getUuid());
      assertTrue(r.getEntities().get(i) instanceof User);
    }
  }
コード例 #11
0
  @Test
  public void testSubkeys() throws Exception {

    UUID applicationId = createApplication("testOrganization", "testSubkeys");
    assertNotNull(applicationId);

    EntityManager em = emf.getEntityManager(applicationId);
    assertNotNull(em);

    Map<String, Object> properties = new LinkedHashMap<String, Object>();
    properties.put("username", "edanuff");
    properties.put("email", "*****@*****.**");

    Entity user = em.create("user", properties);
    assertNotNull(user);

    properties = new LinkedHashMap<String, Object>();
    properties.put("actor", hashMap("displayName", "Ed Anuff").map("objectType", "person"));
    properties.put("verb", "tweet");
    properties.put("content", "I ate a sammich");

    em.addToCollection(user, "activities", em.create("activity", properties));

    properties = new LinkedHashMap<String, Object>();
    properties.put("actor", hashMap("displayName", "Ed Anuff").map("objectType", "person"));
    properties.put("verb", "post");
    properties.put("content", "I wrote a blog post");

    em.addToCollection(user, "activities", em.create("activity", properties));

    properties = new LinkedHashMap<String, Object>();
    properties.put("actor", hashMap("displayName", "Ed Anuff").map("objectType", "person"));
    properties.put("verb", "tweet");
    properties.put("content", "I ate another sammich");

    em.addToCollection(user, "activities", em.create("activity", properties));

    properties = new LinkedHashMap<String, Object>();
    properties.put("actor", hashMap("displayName", "Ed Anuff").map("objectType", "person"));
    properties.put("verb", "post");
    properties.put("content", "I wrote another blog post");

    em.addToCollection(user, "activities", em.create("activity", properties));

    Results r = em.searchCollection(user, "activities", Query.searchForProperty("verb", "post"));
    logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));
    assertEquals(2, r.size());
  }
コード例 #12
0
  @Test
  public void testGroups() throws Exception {
    UUID applicationId = createApplication("testOrganization", "testGroups");
    assertNotNull(applicationId);

    EntityManager em = emf.getEntityManager(applicationId);
    assertNotNull(em);

    Map<String, Object> properties = new LinkedHashMap<String, Object>();
    properties.put("username", "edanuff");
    properties.put("email", "*****@*****.**");

    Entity user1 = em.create("user", properties);
    assertNotNull(user1);

    properties = new LinkedHashMap<String, Object>();
    properties.put("username", "djacobs");
    properties.put("email", "*****@*****.**");

    Entity user2 = em.create("user", properties);
    assertNotNull(user2);

    properties = new LinkedHashMap<String, Object>();
    properties.put("path", "group1");
    Entity group = em.create("group", properties);
    assertNotNull(group);

    em.addToCollection(group, "users", user1);
    em.addToCollection(group, "users", user2);

    properties = new LinkedHashMap<String, Object>();
    properties.put("nickname", "ed");
    em.updateProperties(new SimpleCollectionRef(group, "users", user1), properties);

    Results r =
        em.searchCollection(
            group,
            "users",
            new Query()
                .addEqualityFilter("member.nickname", "ed")
                .withResultsLevel(Results.Level.LINKED_PROPERTIES));
    logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));
    assertEquals(1, r.size());

    em.removeFromCollection(user1, "groups", group);
  }
コード例 #13
0
ファイル: Results.java プロジェクト: capacman/usergrid-stack
 public void mergeEntitiesWithMetadata() {
   if (metadataMerged) {
     return;
   }
   if (metadata == null) {
     return;
   }
   metadataMerged = true;
   getEntities();
   if (entities != null) {
     for (Entity entity : entities) {
       entity.clearMetadata();
       Map<String, Object> entityMetadata = metadata.get(entity.getUuid());
       if (entityMetadata != null) {
         entity.mergeMetadata(entityMetadata);
       }
     }
   }
 }
コード例 #14
0
ファイル: Results.java プロジェクト: capacman/usergrid-stack
 public List<Entity> getEntitiesByType(String type) {
   if (entitiesByType != null) {
     return entitiesByType.get(type);
   }
   getEntities();
   if (entities == null) {
     return null;
   }
   List<Entity> l = null;
   entitiesByType = new LinkedHashMap<String, List<Entity>>();
   for (Entity entity : entities) {
     l = entitiesByType.get(entity.getType());
     if (l == null) {
       l = new ArrayList<Entity>();
       entitiesByType.put(entity.getType(), l);
     }
     l.add(entity);
   }
   return l;
 }
コード例 #15
0
  @Test
  public void testCollectionFilters() throws Exception {
    logger.info("testCollectionFilters");

    UUID applicationId = createApplication("testOrganization", "testCollectionFilters");
    assertNotNull(applicationId);

    EntityManager em = emf.getEntityManager(applicationId);
    assertNotNull(em);

    for (int i = alphabet.length - 1; i >= 0; i--) {
      String name = alphabet[i];
      Map<String, Object> properties = new LinkedHashMap<String, Object>();
      properties.put("name", name);

      em.create("item", properties);
    }

    Query query = Query.fromQL("name < 'delta'");
    Results r = em.searchCollection(em.getApplicationRef(), "items", query);
    logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));
    int i = 0;
    for (Entity entity : r.getEntities()) {
      assertEquals(alphabet[i], entity.getProperty("name"));
      i++;
    }
    assertEquals(3, i);

    query = Query.fromQL("name <= 'delta'");
    r = em.searchCollection(em.getApplicationRef(), "items", query);
    logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));
    i = 0;
    for (Entity entity : r.getEntities()) {
      assertEquals(alphabet[i], entity.getProperty("name"));
      i++;
    }
    assertEquals(4, i);

    query = Query.fromQL("name <= 'foxtrot' and name > 'bravo'");
    r = em.searchCollection(em.getApplicationRef(), "items", query);
    logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));
    i = 2;
    for (Entity entity : r.getEntities()) {
      assertEquals(alphabet[i], entity.getProperty("name"));
      i++;
    }
    assertEquals(6, i);

    query = Query.fromQL("name < 'foxtrot' and name > 'bravo'");
    r = em.searchCollection(em.getApplicationRef(), "items", query);
    logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));
    i = 2;
    for (Entity entity : r.getEntities()) {
      assertEquals(alphabet[i], entity.getProperty("name"));
      i++;
    }
    assertEquals(5, i);

    query = Query.fromQL("name < 'foxtrot' and name >= 'bravo'");
    r = em.searchCollection(em.getApplicationRef(), "items", query);
    logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));
    i = 1;
    for (Entity entity : r.getEntities()) {
      assertEquals(alphabet[i], entity.getProperty("name"));
      i++;
    }
    assertEquals(5, i);

    query = Query.fromQL("name <= 'foxtrot' and name >= 'bravo'");
    r = em.searchCollection(em.getApplicationRef(), "items", query);
    logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));
    i = 1;
    for (Entity entity : r.getEntities()) {
      assertEquals(alphabet[i], entity.getProperty("name"));
      i++;
    }
    assertEquals(6, i);

    query = Query.fromQL("name <= 'foxtrot' and name >= 'bravo' order by name desc");
    r = em.searchCollection(em.getApplicationRef(), "items", query);
    logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));
    i = 6;
    for (Entity entity : r.getEntities()) {
      i--;
      assertEquals(alphabet[i], entity.getProperty("name"));
    }
    assertEquals(1, i);

    query = Query.fromQL("name < 'foxtrot' and name > 'bravo' order by name desc");
    r = em.searchCollection(em.getApplicationRef(), "items", query);
    logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));
    i = 5;
    for (Entity entity : r.getEntities()) {
      i--;
      assertEquals(alphabet[i], entity.getProperty("name"));
    }
    assertEquals(2, i);

    query = Query.fromQL("name < 'foxtrot' and name >= 'bravo' order by name desc");
    r = em.searchCollection(em.getApplicationRef(), "items", query);
    logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));
    i = 5;
    for (Entity entity : r.getEntities()) {
      i--;
      assertEquals(alphabet[i], entity.getProperty("name"));
    }
    assertEquals(1, i);

    query = Query.fromQL("name = 'foxtrot'");
    r = em.searchCollection(em.getApplicationRef(), "items", query);
    logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));
    assertEquals(1, r.size());

    long created = r.getEntity().getCreated();
    UUID entityId = r.getEntity().getUuid();

    query = Query.fromQL("created = " + created);
    r = em.searchCollection(em.getApplicationRef(), "items", query);
    logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));
    assertEquals(1, r.size());
    assertEquals(entityId, r.getEntity().getUuid());
  }
コード例 #16
0
  @Test
  public void pagingAfterDelete() throws Exception {

    UUID applicationId = createApplication("testOrganization", "pagingAfterDelete");
    assertNotNull(applicationId);

    EntityManager em = emf.getEntityManager(applicationId);
    assertNotNull(em);

    int size = 20;
    List<UUID> entityIds = new ArrayList<UUID>();

    for (int i = 0; i < size; i++) {
      Map<String, Object> properties = new LinkedHashMap<String, Object>();
      properties.put("name", "object" + i);
      Entity created = em.create("objects", properties);

      entityIds.add(created.getUuid());
    }

    Query query = new Query();
    query.setLimit(50);

    Results r = em.searchCollection(em.getApplicationRef(), "objects", query);

    logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));

    assertEquals(size, r.size());

    // check they're all the same before deletion
    for (int i = 0; i < size; i++) {
      assertEquals(entityIds.get(i), r.getEntities().get(i).getUuid());
    }

    // now delete 5 items that will span the 10 pages
    for (int i = 5; i < 10; i++) {
      Entity entity = r.getEntities().get(i);
      em.delete(entity);
      entityIds.remove(entity.getUuid());
    }

    // now query with paging
    query = new Query();

    r = em.searchCollection(em.getApplicationRef(), "objects", query);

    assertEquals(10, r.size());

    for (int i = 0; i < 10; i++) {
      assertEquals(entityIds.get(i), r.getEntities().get(i).getUuid());
    }

    // try the next page, set our cursor, it should be the last 5 entities
    query = new Query();
    query.setCursor(r.getCursor());

    r = em.searchCollection(em.getApplicationRef(), "objects", query);

    assertEquals(5, r.size());
    for (int i = 10; i < 15; i++) {
      assertEquals(entityIds.get(i), r.getEntities().get(i - 10).getUuid());
    }
  }
コード例 #17
0
  @Test
  public void orQuery() throws Exception {
    UUID applicationId = createApplication("testOrganization", "orQuery");
    assertNotNull(applicationId);

    EntityManager em = emf.getEntityManager(applicationId);
    assertNotNull(em);

    Map<String, Object> properties = new LinkedHashMap<String, Object>();
    properties.put("keywords", "blah,test,game");
    properties.put("title", "Solitaire");

    Entity game1 = em.create("orquerygame", properties);
    assertNotNull(game1);

    properties = new LinkedHashMap<String, Object>();
    properties.put("keywords", "random,test");
    properties.put("title", "Hearts");

    Entity game2 = em.create("orquerygame", properties);
    assertNotNull(game2);

    // EntityRef
    Query query =
        Query.fromQL("select * where keywords contains 'Random' OR keywords contains 'Game'");

    Results r = em.searchCollection(em.getApplicationRef(), "orquerygames", query);

    assertEquals(2, r.size());

    Entity returned = r.getEntities().get(0);

    assertEquals(game2.getUuid(), returned.getUuid());

    returned = r.getEntities().get(1);

    assertEquals(game1.getUuid(), returned.getUuid());

    query = Query.fromQL("select * where( keywords contains 'Random' OR keywords contains 'Game')");

    r = em.searchCollection(em.getApplicationRef(), "orquerygames", query);

    assertEquals(2, r.size());

    returned = r.getEntities().get(0);

    assertEquals(game2.getUuid(), returned.getUuid());

    returned = r.getEntities().get(1);

    assertEquals(game1.getUuid(), returned.getUuid());

    // field order shouldn't matter USERGRID-375
    query = Query.fromQL("select * where keywords contains 'blah' OR title contains 'blah'");

    r = em.searchCollection(em.getApplicationRef(), "orquerygames", query);

    assertEquals(1, r.size());

    returned = r.getEntities().get(0);

    assertEquals(game1.getUuid(), returned.getUuid());

    query = Query.fromQL("select * where  title contains 'blah' OR keywords contains 'blah'");

    r = em.searchCollection(em.getApplicationRef(), "orquerygames", query);

    assertEquals(1, r.size());

    returned = r.getEntities().get(0);

    assertEquals(game1.getUuid(), returned.getUuid());
  }
コード例 #18
0
  @Test
  public void testCollectionOrdering() throws Exception {
    logger.info("testCollectionOrdering");

    UUID applicationId = createApplication("testOrganization", "testCollectionOrdering");
    assertNotNull(applicationId);

    EntityManager em = emf.getEntityManager(applicationId);
    assertNotNull(em);

    for (int i = alphabet.length - 1; i >= 0; i--) {
      String name = alphabet[i];
      Map<String, Object> properties = new LinkedHashMap<String, Object>();
      properties.put("name", name);

      em.create("item", properties);
    }

    int i = 0;

    Query query = Query.fromQL("order by name");
    Results r = em.searchCollection(em.getApplicationRef(), "items", query);
    for (Entity entity : r.getEntities()) {
      assertEquals(alphabet[i], entity.getProperty("name"));
      i++;
    }

    query = Query.fromQL("order by name").withCursor(r.getCursor());
    r = em.searchCollection(em.getApplicationRef(), "items", query);
    for (Entity entity : r.getEntities()) {
      assertEquals(alphabet[i], entity.getProperty("name"));
      i++;
    }

    query = Query.fromQL("order by name").withCursor(r.getCursor());
    r = em.searchCollection(em.getApplicationRef(), "items", query);
    for (Entity entity : r.getEntities()) {
      assertEquals(alphabet[i], entity.getProperty("name"));
      i++;
    }

    assertEquals(alphabet.length, i);

    i = alphabet.length;

    query = Query.fromQL("order by name desc");
    r = em.searchCollection(em.getApplicationRef(), "items", query);
    for (Entity entity : r.getEntities()) {
      i--;
      assertEquals(alphabet[i], entity.getProperty("name"));
    }

    query = Query.fromQL("order by name desc").withCursor(r.getCursor());
    r = em.searchCollection(em.getApplicationRef(), "items", query);
    // logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities()));
    for (Entity entity : r.getEntities()) {
      i--;
      assertEquals(alphabet[i], entity.getProperty("name"));
    }

    query = Query.fromQL("order by name desc").withCursor(r.getCursor());
    r = em.searchCollection(em.getApplicationRef(), "items", query);
    for (Entity entity : r.getEntities()) {
      i--;
      assertEquals(alphabet[i], entity.getProperty("name"));
    }

    assertEquals(0, i);
  }
コード例 #19
0
  @Test
  public void testCollection() throws Exception {
    UUID applicationId = createApplication("testOrganization", "testCollection");
    assertNotNull(applicationId);

    EntityManager em = emf.getEntityManager(applicationId);
    assertNotNull(em);

    Map<String, Object> properties = new LinkedHashMap<String, Object>();
    properties.put("username", "edanuff");
    properties.put("email", "*****@*****.**");

    Entity user = em.create("user", properties);
    assertNotNull(user);

    properties = new LinkedHashMap<String, Object>();
    properties.put(
        "actor",
        new LinkedHashMap<String, Object>() {
          {
            put("displayName", "Ed Anuff");
            put("objectType", "person");
          }
        });
    properties.put("verb", "tweet");
    properties.put("content", "I ate a sammich");
    properties.put("ordinal", 3);

    Entity activity = em.create("activity", properties);
    assertNotNull(activity);

    logger.info("" + activity.getClass());
    logger.info(JsonUtils.mapToFormattedJsonString(activity));

    activity = em.get(activity.getUuid());

    logger.info("" + activity.getClass());
    logger.info(JsonUtils.mapToFormattedJsonString(activity));

    em.addToCollection(user, "activities", activity);

    // test queries on the collection

    properties = new LinkedHashMap<String, Object>();
    properties.put(
        "actor",
        new LinkedHashMap<String, Object>() {
          {
            put("displayName", "Ed Anuff");
            put("objectType", "person");
          }
        });
    properties.put("verb", "tweet2");
    properties.put("content", "I ate a pickle");
    properties.put("ordinal", 2);
    Entity activity2 = em.create("activity", properties);
    activity2 = em.get(activity2.getUuid());
    em.addToCollection(user, "activities", activity2);

    properties = new LinkedHashMap<String, Object>();
    properties.put(
        "actor",
        new LinkedHashMap<String, Object>() {
          {
            put("displayName", "Ed Anuff");
            put("objectType", "person");
          }
        });
    properties.put("verb", "tweet2");
    properties.put("content", "I ate an apple");
    properties.put("ordinal", 1);
    Entity activity3 = em.create("activity", properties);
    activity3 = em.get(activity3.getUuid());
    em.addToCollection(user, "activities", activity3);

    // empty query
    Query query = new Query();
    Results r = em.searchCollection(user, "activities", query);
    assertEquals(3, r.size()); // success

    // query verb
    query = new Query().addEqualityFilter("verb", "tweet2");
    r = em.searchCollection(user, "activities", query);
    assertEquals(2, r.size());

    // query verb, sort created
    query = new Query().addEqualityFilter("verb", "tweet2");
    query.addSort("created");
    r = em.searchCollection(user, "activities", query);
    assertEquals(2, r.size());
    List<Entity> entities = r.getEntities();
    assertEquals(entities.get(0).getUuid(), activity2.getUuid());
    assertEquals(entities.get(1).getUuid(), activity3.getUuid());

    // query verb, sort ordinal
    query = new Query().addEqualityFilter("verb", "tweet2");
    query.addSort("ordinal");
    r = em.searchCollection(user, "activities", query);
    assertEquals(2, r.size());
    entities = r.getEntities();
    assertEquals(entities.get(0).getUuid(), activity3.getUuid());
    assertEquals(entities.get(1).getUuid(), activity2.getUuid());

    // empty query, sort content
    query = new Query();
    query.addSort("content");
    r = em.searchCollection(user, "activities", query);
    assertEquals(3, r.size());
    entities = r.getEntities();
    logger.info(JsonUtils.mapToFormattedJsonString(entities));
    assertEquals(entities.get(0).getUuid(), activity2.getUuid());
    assertEquals(entities.get(1).getUuid(), activity.getUuid());
    assertEquals(entities.get(2).getUuid(), activity3.getUuid());

    // empty query, sort verb
    query = new Query();
    query.addSort("verb");
    r = em.searchCollection(user, "activities", query);
    assertEquals(3, r.size());

    // empty query, sort ordinal
    query = new Query();
    query.addSort("ordinal");
    r = em.searchCollection(user, "activities", query);
    assertEquals(3, r.size());
    entities = r.getEntities();
    assertEquals(entities.get(0).getUuid(), activity3.getUuid());
    assertEquals(entities.get(1).getUuid(), activity2.getUuid());
    assertEquals(entities.get(2).getUuid(), activity.getUuid());

    // query ordinal
    query = new Query().addEqualityFilter("ordinal", 2);
    r = em.searchCollection(user, "activities", query);
    assertEquals(1, r.size());

    // query ordinal and sort ordinal
    query = new Query().addEqualityFilter("ordinal", 2);
    query.addSort("ordinal");
    r = em.searchCollection(user, "activities", query);
    assertEquals(1, r.size());
  }