How to use

select

method

in

pl.edu.icm.yadda.service2.browse.facade.Relation

f = rel.select(query.where(new ComplexClause(
    ComplexClause.Operator.OR, clausesExtId)));
f = rel.select(query);

browserFacade.relation(ElementView.ELEMENT_VIEW_NAME)
       .withPageSize(pageSize)
       .select(Query.fields(ElementView.FIELDS_IDX_EXT_ID)
             .where(Condition.eq(ElementView.FIELD_EXTID, rootExtId))),
pageSize);

@Override
public Map<Integer, String> getFromReferences(String sourceId) throws AnalysisException {
  try {
    Map<Integer, String> references = new HashMap<Integer, String>();
    Relation refsRelation = getRefsRelation().withPageSize(PAGE_SIZE);
    Selection selection = Query.fields(REFS_RELATION_POSITION_FIELD, REFS_RELATION_TARGET_FIELD)
                  .where(getRefsSourceCondition(sourceId));
    
    FetcherIterator fetcherIterator = new FetcherIterator(refsRelation.select(selection), PAGE_SIZE);
    while (fetcherIterator.hasNext()) {
      Serializable[] record = fetcherIterator.next();
      references.put(Integer.valueOf(record[0].toString()), record[1].toString());
    }
    return references;
  } catch (BrowseException ex) {
     throw new AnalysisException(ex);
  }
}

@Override
public Map<String, Integer> getToReferences(String targetId) throws AnalysisException {
  try {
    Map<String, Integer> references = new HashMap<String, Integer>();
    Relation refsRelation = getRefsRelation().withPageSize(PAGE_SIZE);
    
    FetcherIterator fetcherIterator = new FetcherIterator(refsRelation.select(
        Query.fields(REFS_RELATION_SOURCE_FIELD, REFS_RELATION_POSITION_FIELD)
        .where(getRefsTargetCondition(targetId))), PAGE_SIZE);
    while (fetcherIterator.hasNext()) {
      Serializable[] record = fetcherIterator.next();
      references.put(record[0].toString(), Integer.valueOf(record[1].toString()));
    }
    return references;
  } catch (BrowseException ex) {
    throw new AnalysisException(ex);
  }
}

contrViewFetcher = rel.select(query.where(new ComplexClause(
    ComplexClause.Operator.AND, clauses)));
contrViewFetcher = rel.select(query);

protected void notifyChildrenOfDeleted(String id,
    Set<String> parentsToInvalidate) throws YaddaException,
    BrowseException {
  Selection selection = Query.fields(ElementView.FIELD_PARENT_EXTID)
                .where(Condition.eq(ElementView.FIELD_EXTID, id));
  
  FetcherIterator fi = new FetcherIterator(
      browserFacade.relation(ElementView.ELEMENT_VIEW_NAME)
             .withPageSize(BROWSE_PAGE_SIZE)
             .select(selection), 
      BROWSE_PAGE_SIZE);
  
  while (fi.hasNext()) {
    Serializable[] row = fi.next();
    parentsToInvalidate.add(row[0].toString());
  }
  
}

@Override
public Map<Integer, String> getFromReferencesAndLock(String sourceId) throws AnalysisException {
  try {
    Map<Integer, String> references = new HashMap<Integer, String>();
    Relation refsRelation = getRefsRelation().withPageSize(PAGE_SIZE);
    FetcherIterator fetcherIterator = new FetcherIterator(refsRelation.select(
        Query.fields(REFS_RELATION_POSITION_FIELD, REFS_RELATION_TARGET_FIELD)
        .where(getRefsSourceCondition(sourceId))), PAGE_SIZE);
    while (fetcherIterator.hasNext()) {
      Serializable[] record = fetcherIterator.next();
      references.put(Integer.valueOf(record[0].toString()), record[1].toString());
    }
    waitForSource(sourceId);
    return references;
  } catch (BrowseException ex) {
    throw new AnalysisException(ex);
  } catch (InterruptedException ex) {
    throw new AnalysisException(ex);
  }
}

@Override
protected Dictionary loadDictonary() throws ServiceException {
  
  try {
    final int pageSize = 100;
    
    Relation relation = getDirectoryRelation();        
    Fetcher f = relation.withPageSize(pageSize)
              .select(Query.fields("position", "licenceId"));
    
    Dictionary dict = new Dictionary();
    
    FetcherIterator iterator = new FetcherIterator(f, pageSize);
    while (iterator.hasNext()) {
      Serializable[] row = iterator.next();
      dict.entries.put((Short)row[0], (String)row[1]);
      dict.lastEntry = (short)Math.max((Short)row[0], dict.lastEntry);
    }
                      
    return dict;
    
  } catch (BrowseException e) {
    throw new ServiceException(e);
  }
  
}

protected PagingResponse<T> processSelection(Selection sel, String relation,
    int pageSize, Object[] extraData)
    throws BrowseException, ServiceException {
  
  int ps = pageSize > 0 ? pageSize : BUFFER_PAGE_SIZE;
  
  Fetcher fetcher = browser.relation(relation, new String[] {ViewConstants.TAG_READY})
               .withPageSize(ps)
               .select(sel);
  
  List<T> li = decodeResultPage(fetcher, ps, extraData);
  Token t = new Token(fetcher.getCookie(), encodeExtraData(extraData), 0, ps);
  t.setHasNextPage(li.size() >= ps);
  PagingResponse<T> res = new PagingResponse<T>(li, t);
  return res;
}

protected Map<String, Set<ElementTreeNode>> getChildrenFromRelation(
    ElementTreeNode parent) throws BrowseException {
  Map<String, Set<ElementTreeNode>> result = new HashMap<String, Set<ElementTreeNode>>();
  Relation relation = browserFacade.relation(ElementView.ELEMENT_VIEW_NAME)
                   .withPageSize(BROWSE_PAGE_SIZE);
  Selection selection = Query.fields(ElementView.FIELD_PARENT_EXTID, ElementView.FIELD_EXTID,
                    ElementView.FIELD_LEVEL_EXTID, ElementView.FIELD_TEXT,
                    ElementView.FIELD_HIERARCHY)
                .where(Condition.eq(ElementView.FIELD_PARENT_EXTID, parent.getElementExtId()));
  
  FetcherIterator fi = new FetcherIterator(relation.select(selection), BROWSE_PAGE_SIZE);
  while (fi.hasNext()) {
    Serializable[] row = fi.next();
    String hierarchyId = (String) row[4];
    if (result.get(hierarchyId) == null) {
      result.put(hierarchyId, new HashSet<ElementTreeNode>());
    }
    ElementTreeNode child = new ElementTreeNode(row[1].toString());
    child.setParentExtId(parent.getElementExtId());
    child.setParentLevelExtId(parent.getElementLevelExtId());
    child.setParentText(parent.getElementText());
    child.setElementLevelExtId(row[2].toString());
    child.setElementText(row[3].toString());
    result.get(hierarchyId).add(child);
  }
  return result;
}

@Override
public Fetcher browseSubscribedItems(String libraryId,
    Map<String, String> filters) {
  try {
    Relation rel = browserFacade.relation(SubscriberView.VIEW_NAME,    requiredTags)
                  .withPageSize(1024);
    Selection query = Query.fields(SubscriberView.FIELD_TOP_ELEMENT_ID,
        SubscriberView.FIELD_TOP_ELEMENT_NAME,
        SubscriberView.FIELD_ELEMENT_ID,
        SubscriberView.FIELD_ELEMENT_NAME);
    Fetcher f = rel.select(query
        .where(Condition.eq(SubscriberView.FIELD_CONTRIBUTOR_ID,
            libraryId))
        .upBy(SubscriberView.FIELD_TOP_ELEMENT_NAME_SORTKEY)
        .upBy(SubscriberView.FIELD_TOP_ELEMENT_ID)
        .upBy(SubscriberView.FIELD_ELEMENT_NAME_SORTKEY));
    return f;
  } catch (NoSuchRelationException e) {
    log.error("Error getting subscriptions!", e);
    throw new SystemException(Modules.BROWSER,
        "Error getting subscriptions!", e);
  } catch (NoSuchFieldInRelationException e) {
    log.error("Error getting subscriptions!", e);
    throw new SystemException(Modules.BROWSER,
        "Error getting subscriptions!", e);
  }
}

f = rel.select(query.where(new ComplexClause(
    ComplexClause.Operator.AND, clauses)));
f = rel.select(query);

.select(Query.fields(DIRTY_RELATION_SOURCE_FIELD)
      .upBy(DIRTY_RELATION_SOURCE_FIELD));

    ContributorView.FIELD_CONTRIBUTOR_ID);
Fetcher f = rel.select(query.where(SimpleClause.eq(ContributorView.FIELD_CONTRIBUTOR_MD5, id)));
ResultPage page = f.getPage();