Exemplo n.º 1
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());
  }
Exemplo n.º 2
0
  @Test
  public void testCase2() throws ODKDatastoreException {

    CallingContext cc = TestContextFactory.getCallingContext();
    Datastore ds = cc.getDatastore();
    User user = cc.getCurrentUser();
    MyRelation rel = MyRelation.assertRelation(cc);

    Query query = ds.createQuery(rel, "QueryResultTest.testCase2", user);
    query.addFilter(MyRelation.fieldInt, FilterOperation.GREATER_THAN, SET_SIZE - 2);
    query.addSort(MyRelation.fieldDate, Direction.ASCENDING);
    query.addSort(MyRelation.fieldDbl, Direction.DESCENDING);

    Set<String> pkSet = new HashSet<String>();

    int len = 0;
    QueryResult result = query.executeQuery(null, 10);
    len += result.getResultList().size();
    assertEquals(true, result.hasMoreResults());
    assertEquals(10, result.getResultList().size());

    for (CommonFieldsBase cb : result.getResultList()) {
      assertEquals(false, pkSet.contains(cb.getUri()));
      pkSet.add(cb.getUri());
      ((MyRelation) cb).print();
    }
    boolean done = false;
    QueryResumePoint startCursor = result.getResumeCursor();
    while (!done) {
      System.out.println("Issuing follow-up query");
      result = query.executeQuery(startCursor, 20);
      len += result.getResultList().size();
      startCursor = result.getResumeCursor();
      done = !result.hasMoreResults();

      for (CommonFieldsBase cb : result.getResultList()) {
        assertEquals(false, pkSet.contains(cb.getUri()));
        pkSet.add(cb.getUri());
        ((MyRelation) cb).print();
      }
    }

    assertEquals(false, result.hasMoreResults());
    assertEquals(2 * values.length, len);
    System.out.println("done with testCase2");
  }
Exemplo n.º 3
0
  public static List<StorageNode> getStorageNodesInFolder(String path, Owner owner) {

    DatastoreService ds = DatastoreServiceFactory.getDatastoreService();

    ArrayList<StorageNode> nodes = new ArrayList<StorageNode>();

    String folderPath = PathHelper.getFolderpath(path);

    // Read folders
    Query q = new Query("Folder");
    q.addFilter("path", FilterOperator.GREATER_THAN_OR_EQUAL, path);
    q.addFilter("path", FilterOperator.LESS_THAN, path + "\ufffd");
    q.addFilter("ownerId", FilterOperator.EQUAL, owner.getId());

    PreparedQuery pq = ds.prepare(q);
    List<Entity> results = pq.asList(FetchOptions.Builder.withLimit(99999));
    for (Entity e : results) {
      Folder f = new Folder();
      ReflectionHelper.setPropertiesFromEntity(Folder.class, f, e);

      log.debug("Folder compare: {} =?= {}", PathHelper.getFolderpath(f.getPath()), folderPath);
      if (PathHelper.getFolderpath(f.getPath()).equals(folderPath)) {
        nodes.add(f);
      }
    }

    // Read files
    Query q2 = new Query("File");
    q2.addFilter("path", FilterOperator.GREATER_THAN_OR_EQUAL, path);
    q2.addFilter("path", FilterOperator.LESS_THAN, path + "\ufffd");
    q2.addFilter("ownerId", FilterOperator.EQUAL, owner.getId());

    PreparedQuery pq2 = ds.prepare(q);
    List<Entity> results2 = pq2.asList(FetchOptions.Builder.withLimit(99999));
    for (Entity e : results2) {
      File f = new File();
      ReflectionHelper.setPropertiesFromEntity(File.class, f, e);

      log.debug("File compare: {} =?= {}", PathHelper.getFolderpath(f.getPath()), folderPath);
      if (PathHelper.getFolderpath(f.getPath()).equals(folderPath)) {

        nodes.add(f);
      }
    }

    return nodes;
  }
Exemplo n.º 4
0
  @Test
  public void testCase3() throws ODKDatastoreException {

    CallingContext cc = TestContextFactory.getCallingContext();
    Datastore ds = cc.getDatastore();
    User user = cc.getCurrentUser();
    MyRelation rel = MyRelation.assertRelation(cc);
    System.out.println("start testCase3");

    Query query = ds.createQuery(rel, "QueryResultTest.testCase3(1st)", user);
    query.addFilter(MyRelation.fieldDbl, FilterOperation.EQUAL, new BigDecimal("0.9"));
    query.addFilter(MyRelation.fieldBool, FilterOperation.EQUAL, true);
    query.addSort(MyRelation.fieldInt, Direction.ASCENDING);
    query.addSort(MyRelation.fieldDate, Direction.DESCENDING);

    Query backquery = ds.createQuery(rel, "QueryResultTest.testCase3(2nd)", user);
    backquery.addFilter(MyRelation.fieldDbl, FilterOperation.EQUAL, new BigDecimal("0.9"));
    backquery.addFilter(MyRelation.fieldBool, FilterOperation.EQUAL, true);
    backquery.addSort(MyRelation.fieldInt, Direction.DESCENDING);
    backquery.addSort(MyRelation.fieldDate, Direction.ASCENDING);

    Set<String> pkTotalSet = new HashSet<String>();

    List<String> pkOrdering = new ArrayList<String>();

    int TOTAL_SIZE = 3 * SET_SIZE;
    int fetchSizes[] = {1, 2, 1021, 303, 101, 2831};
    int idxFetch = 4;
    int len = 0;
    QueryResult result = query.executeQuery(null, fetchSizes[idxFetch]);
    len += result.getResultList().size();
    assertEquals(true, result.hasMoreResults());
    assertEquals(fetchSizes[idxFetch], result.getResultList().size());

    System.out.println("Accumulating forward query results");
    for (CommonFieldsBase cb : result.getResultList()) {
      assertEquals(false, pkOrdering.contains(cb.getUri()));
      assertEquals(false, pkTotalSet.contains(cb.getUri()));
      pkOrdering.add(cb.getUri());
      pkTotalSet.add(cb.getUri());
      ((MyRelation) cb).print();
    }

    System.out.println("Verifying initial backward query is empty");
    QueryResult backResult = backquery.executeQuery(result.getBackwardCursor(), pkOrdering.size());
    assertEquals(false, backResult.hasMoreResults());
    assertEquals(0, backResult.getResultList().size());

    boolean notFirst = false;
    boolean done = false;
    QueryResumePoint startCursor = result.getResumeCursor();
    while (!done) {
      idxFetch = (idxFetch + 1) % fetchSizes.length;
      System.out.println("Issuing follow-up query");
      result = query.executeQuery(startCursor, fetchSizes[idxFetch]);
      len += result.getResultList().size();
      startCursor = result.getResumeCursor();
      done = !result.hasMoreResults();

      System.out.println("Verifying backward query against ordering of earlier result");
      backResult = backquery.executeQuery(result.getBackwardCursor(), pkOrdering.size());
      assertEquals(notFirst, backResult.hasMoreResults());
      notFirst = true;
      assertEquals(pkOrdering.size(), backResult.getResultList().size());
      for (int i = 0; i < pkOrdering.size(); ++i) {
        CommonFieldsBase cb = backResult.getResultList().get(i);
        ((MyRelation) cb).print();
        assertEquals(pkOrdering.get(pkOrdering.size() - i - 1), cb.getUri());
      }

      System.out.println("Accumulating forward query results");
      pkOrdering.clear();
      for (CommonFieldsBase cb : result.getResultList()) {
        assertEquals(false, pkOrdering.contains(cb.getUri()));
        assertEquals(false, pkTotalSet.contains(cb.getUri()));
        pkOrdering.add(cb.getUri());
        pkTotalSet.add(cb.getUri());
        ((MyRelation) cb).print();
      }
    }

    idxFetch = (idxFetch + 1) % fetchSizes.length;
    System.out.println("Before Issuing (what should be empty) follow-up query");
    result = query.executeQuery(startCursor, fetchSizes[idxFetch]);
    len += result.getResultList().size();
    startCursor = result.getResumeCursor();
    done = !result.hasMoreResults();

    System.out.println("Verifying backward query against ordering of earlier result");
    // backquery should match existing data
    backResult = backquery.executeQuery(result.getBackwardCursor(), pkOrdering.size());
    assertEquals(true, backResult.hasMoreResults());
    assertEquals(pkOrdering.size(), backResult.getResultList().size());
    for (int i = 0; i < pkOrdering.size(); ++i) {
      CommonFieldsBase cb = backResult.getResultList().get(i);
      ((MyRelation) cb).print();
      assertEquals(pkOrdering.get(pkOrdering.size() - i - 1), cb.getUri());
    }

    assertEquals(false, result.hasMoreResults());
    assertEquals(0, result.getResultList().size());

    idxFetch = (idxFetch + 1) % fetchSizes.length;
    System.out.println("Before Re-Issuing (what should be empty) follow-up query");
    // this should be an empty list
    result = query.executeQuery(startCursor, fetchSizes[idxFetch]);
    assertEquals(false, result.hasMoreResults());
    assertEquals(0, result.getResultList().size());

    System.out.println("Verifying backward query (again) against ordering of earlier result");
    // backquery should match existing data
    backResult = backquery.executeQuery(result.getBackwardCursor(), pkOrdering.size());
    assertEquals(true, backResult.hasMoreResults());
    assertEquals(pkOrdering.size(), backResult.getResultList().size());
    for (int i = 0; i < pkOrdering.size(); ++i) {
      CommonFieldsBase cb = backResult.getResultList().get(i);
      ((MyRelation) cb).print();
      assertEquals(pkOrdering.get(pkOrdering.size() - i - 1), cb.getUri());
    }

    assertEquals(TOTAL_SIZE, len);
  }
Exemplo n.º 5
0
 private Entity getBlobInfoEntityThroughQuery(String creationHandle) {
   Query query = new Query(BlobInfoFactory.KIND);
   query.addFilter(BLOB_INFO_CREATION_HANDLE_PROPERTY, Query.FilterOperator.EQUAL, creationHandle);
   return getDatastoreService().prepare(query).asSingleEntity();
 }
Exemplo n.º 6
0
  public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    int index;

    DatastoreService ds;
    MemcacheService ms;

    Cookie[] cookies;
    boolean insideFlag;

    String delpw;
    String paramOffset;
    String paramSize;
    int offset;
    int size;

    Key postObjGroupKey;
    Query q;
    List<Entity> postObjList;
    PostObj postObj;

    Gson gson;
    List<String> filelinkList;

    resp.setCharacterEncoding("UTF-8");
    resp.setContentType("text/plain");

    ds = DatastoreServiceFactory.getDatastoreService();
    ms = MemcacheServiceFactory.getMemcacheService();

    insideFlag = false;
    try {
      cookies = req.getCookies();
      if (cookies.length > 0) {
        if (ms.contains(cookies[0].getValue()) == true) {
          insideFlag = true;
        }
      }
    } catch (Exception e) {
      insideFlag = false;
    }

    delpw = req.getParameter("delpw");
    if (delpw != null) {
      if (delpw.equals("") == true) {
        delpw = null;
      }
    }

    paramOffset = req.getParameter("offset");
    if (paramOffset != null) {
      offset = Integer.valueOf(paramOffset);
    } else {
      offset = 0;
    }

    paramSize = req.getParameter("size");
    if (paramSize != null) {
      size = Integer.valueOf(paramSize);
    } else {
      size = 4096;
    }

    postObjGroupKey = KeyFactory.createKey("PostObjGroup", 1L);
    q = new Query("PostObj", postObjGroupKey);
    if (delpw != null) {
      q.addFilter("delpw", FilterOperator.EQUAL, delpw);
      q.addSort("delpw");
    }
    q.addSort("posttime", SortDirection.DESCENDING);
    postObjList = ds.prepare(q).asList(FetchOptions.Builder.withOffset(offset).limit(size));

    postObj = new PostObj();
    filelinkList = new ArrayList<String>();
    for (index = 0; index < postObjList.size(); index++) {
      postObj.getDB(postObjList.get(index));
      if ((postObj.flag.equals("showgallery") == false && insideFlag == true)
          || (postObj.flag.equals("showgallery") == true && insideFlag == false)
          || delpw != null) {
        filelinkList.add(postObj.filelink);
      }
    }

    gson = new Gson();
    resp.getWriter().print(gson.toJson(filelinkList));
  }