How to use

WikittyQuery

in

org.nuiton.wikitty.query

/**
 * Parse et ajoute un bout de requete. Cette requete est prise comme une
 * condition terminal si l'on veut continuer a construire la requete, il
 * faut avoir ajouter avant une
 * {@link #and()}, {@link #or()}, {@link #not()}, {@link #containsOne()}
 * @param query la requete a ajouter (peut-etre vide ou nul, dans ce cas, la
 * condition utiliser est "true")
 * @param includeExtra copy offset, limit, depth found in query if true
 * @return {@code this} with the {@code c} restriction added.
 */
public M parse(String query, boolean includeExtra) {
  if (StringUtils.isNotBlank(query)) {
    WikittyQuery filter = WikittyQueryParser.parse(query);
    addCondition(filter.getCondition(), true);
    if (includeExtra) {
      WikittyQuery q = getQuery();
      q.setOffset(filter.getOffset());
      q.setLimit(filter.getLimit());
      q.setWikittyFieldSearchDepth(filter.getWikittyFieldSearchDepth());
    }
  } else {
    addCondition(new True());
  }
  return this.asM();
}

/**
 * La query passee dans le constructeur ou une nouvelle query si aucune
 * query n'avait ete passee dans le constructeur
 * 
 * @return
 */
public WikittyQuery getQuery() {
  if (query == null) {
    query = new WikittyQuery();
  }
  // la condition de la query doit toujours refleter la valeur courante
  // de la condition en cours de creation
  query.setCondition(getCondition());
  return query;
}

@Override
public List<Map<String, Object>> findByQuery(String securityToken, List<WikittyQuery> queries) {
  List<Map<String, Object>> result = new ArrayList<Map<String, Object>>(queries.size());
  List<WikittyQuery> queriesLimited = new ArrayList<WikittyQuery>(queries.size());
  for (WikittyQuery c : queries) {
    WikittyQuery climit = c.copy().setOffset(0).setLimit(1);
    queriesLimited.add(climit);
  }
  List<WikittyQueryResult<Map<String, Object>>> idsList = findAllByQuery(
      securityToken, queriesLimited);
  for (WikittyQueryResult<Map<String, Object>> ids : idsList) {
    if (ids.size() > 0) {
      result.add(ids.peek());
    } else {
      result.add(null);
    }
  }
  if (queries.size() != result.size()) {
    log.error(String.format("Query input list (%s) has not same size that result list (%s)",
        queries.size(), result.size()));
  }
  return result;
}

/**
 * Retourne la clause Select de la Query, ou null si la query n'a pas de select
 * @return
 * @since 3.10
 */
public Select getSelect() {
  Select result = null;
  if (isSelectQuery()) {
    result = (Select)getCondition();
  }
  return result;
}

/**
 * retourne une copie de cette query sans la clause select. Si cette
 * query n'avait pas de select la query retournee est strictement equivalente.
 *
 * @return
 * @since 3.10
 */
public WikittyQuery getWhereQuery() {
  Condition newCond = getWhere();
  // copy de la query sans le select
  WikittyQuery result = this.copy();
  result.setCondition(newCond);
  return result;
}

/**
 * retourne la clause where de la query, la clause where peut-etre la meme
 * chose que le {@link #getCondition} si la clause n'a pas de select
 * @return
 * @since 3.10
 */
public Condition getWhere() {
  Condition result = getCondition();
  if (isSelectQuery()) {
    result = getSelect().getSubCondition();
  }
  return result;
}

@Override
public boolean visitEnter(WikittyQuery o) {
  WikittyQuery q = getQuery();
  q.setFacetExtension(q.isFacetExtension());
  q.setFacetField(new ArrayList<Element>(o.getFacetField()));
  q.setFacetLimit(o.getFacetLimit());
  q.setFacetMinCount(o.getFacetMinCount());
  q.setOffset(o.getOffset());
  q.setLimit(o.getLimit());
  q.setFacetSort(o.getFacetSort());
  q.setName(o.getName());
  q.setSortAscending(new ArrayList<Element>(o.getSortAscending()));
  q.setSortDescending(new ArrayList<Element>(o.getSortDescending()));
  q.setWikittyFieldSearchDepth(o.getWikittyFieldSearchDepth());
  for (FacetQuery c : o.getFacetQuery()) {
    WikittyQueryVisitorCopy v = new WikittyQueryVisitorCopy();
    c.getCondition().accept(v);
    Condition condition = v.getCondition();
    q.addFacetQuery(c.getName(), condition);
  }
  return true;
}

if (query.isSelectQuery()) {
  select = query.getSelect();
  queryWithoutSelect = query.getWhereQuery();
  if (queryWithoutSelect.getCondition() == null) {
    queryWithoutSelect.setCondition(new True());
    transaction, this, elementModifier, queryWithoutSelect.getWikittyFieldSearchDepth());
queryWithoutSelect.getCondition().accept(v);
String queryString = v.getSolrQuery();
SolrQuery querySolr = new SolrQuery(SOLR_QUERY_PARSER + queryString);
int offset = queryWithoutSelect.getOffset();
int limit = queryWithoutSelect.getLimit();
List<Element> sortAscending = queryWithoutSelect.getSortAscending();
if(sortAscending != null) {
  for (Element sort : sortAscending) {
List<Element> sortDescending = queryWithoutSelect.getSortDescending();
if(sortDescending != null) {
  for (Element sort : sortDescending) {
boolean isFacetExtension = queryWithoutSelect.isFacetExtension();
List<Element> facetField = queryWithoutSelect.getFacetField();
List<FacetQuery> facetQuery = queryWithoutSelect.getFacetQuery();
    || CollectionUtils.isNotEmpty(facetQuery)) {
  querySolr.setFacet(true);

@Override
public boolean equals(Object o) {
  boolean result;
  if (o == null) {
    result = false;
  } else if (ObjectUtils.equals(this.getClass(), o.getClass())) {
    WikittyQuery other = (WikittyQuery)o;
    result = ObjectUtils.equals(this.getName(), other.getName()) &&
        ObjectUtils.equals(this.getOffset(), other.getOffset()) &&
        ObjectUtils.equals(this.getLimit(), other.getLimit()) &&
        ObjectUtils.equals(this.isFacetExtension(), other.isFacetExtension()) &&
        ObjectUtils.equals(this.getFacetField(), other.getFacetField()) &&
        ObjectUtils.equals(this.getSortAscending(), other.getSortAscending()) &&
        ObjectUtils.equals(this.getSortDescending(), other.getSortDescending()) &&
        ObjectUtils.equals(this.getFacetLimit(), other.getFacetLimit()) &&
        ObjectUtils.equals(this.getFacetSort(), other.getFacetSort()) &&
        ObjectUtils.equals(this.getFacetMinCount(), other.getFacetMinCount()) &&
        ObjectUtils.equals(this.getFacetQuery(), other.getFacetQuery()) &&
        ObjectUtils.equals(this.getCondition(), other.getCondition()) &&
        ObjectUtils.equals(this.getWikittyFieldSearchDepth(), other.getWikittyFieldSearchDepth());
  } else {
    result = false;
  }
  return result;
}

WikittyQuery queryWithoutSelect = query;
  if (query.isSelectQuery()) {
    select = query.getSelect();
    queryWithoutSelect = query.getWhereQuery();
    if (queryWithoutSelect.getCondition() == null) {
      queryWithoutSelect.setCondition(new org.nuiton.wikitty.query.conditions.True());
int offset = queryWithoutSelect.getOffset();
int limit = queryWithoutSelect.getLimit();
List<String> ids = new LinkedList<String>();
FacetPredicate facets = new FacetPredicate(this, transaction, queryWithoutSelect);
if (!queryWithoutSelect.getSortAscending().isEmpty()
    || !queryWithoutSelect.getSortDescending().isEmpty() ) {
  Collections.sort(wikitties, new WikittyComparator(
      queryWithoutSelect.getSortAscending(), queryWithoutSelect.getSortDescending()));
for (Wikitty w : wikitties) {
  String id = w.getWikittyId();
  Condition c = queryWithoutSelect.getCondition();
  if (!w.isDeleted()) {
    if (checkRestriction(this, transaction, c, w)) {
    queryWithoutSelect.getName(), offset, totalResult,
    query, queryWithoutSelect.getCondition().toString(),
    values, selectResult, ids, facets.getFacets(), 0, 0);

      .extContainsAll(extensions).end();
} else {
  serviceQuery = criteria.copy();
  WikittyQueryMaker queryMaker;
  if (serviceQuery.getCondition() instanceof Select) {
    Select select = (Select)serviceQuery.getCondition();
    queryMaker = new WikittyQueryMaker()
        .select(select.getFunction())
        .and().condition(serviceQuery.getCondition())
        .extContainsAll(extensions);
  serviceQuery.setCondition(queryMaker.getCondition());
if (!(query.getCondition() instanceof Select)) {
  query.setOffset(0);
  query.setLimit(1);
query.setFacetExtension(false);
query.setFacetField();
query.setFacetQuery();

treeQuery.getCondition().accept(v);
String queryString = v.getSolrQuery();
SolrQuery querySolr = new SolrQuery(SOLR_QUERY_PARSER + queryString);
    attQueryMaker.and().condition(filter.getCondition());
      .setOffset(0).setLimit(0)
      .addFacetField(new ElementField(TREENODE_ATTACHED_ALL))
      .setFacetLimit(Integer.MAX_VALUE);
  WikittyQueryResult<String> attSearch =
      findAllByQuery(transaction, attQuery).convertMapToSimple();

/**
 * Null field are not used in search request.
 *
 * @param e sample wikitty
 * @param first
 * @param limit
 * @param fieldFacet
 * @return
 */
public <E extends BusinessEntityImpl> WikittyQueryResult<E> findAllByExample(E e,
    int first, int limit, ElementField ... fieldFacet) {
  long start = TimeLog.getTime();
  WikittyQuery query = new WikittyQueryMaker().wikitty(e).end()
      .setOffset(first).setLimit(limit)
      .setFacetField(fieldFacet);
  WikittyQueryResult<E> result =
      findAllByQuery((Class<E>)e.getClass(),
      Collections.singletonList(query), false).get(0);
  
  timeLog.log(start, "findAllByExample<limit>");
  return result;
}

    .condition(q.getCondition())
    .containsOne(Element.ID, ids).end()
    .setOffset(0).setLimit(WikittyQuery.MAX);
WikittyQueryResult<String> queryResult =
    ws.<String>findAllByQuery(token, Collections.singletonList(checkQuery)).get(0).convertMapToSimple();

@Test
public void testSearchExtensionFacetExplicitly() throws Exception {
  // essai de facettiser sur les extensions
  WikittyQuery query = new WikittyQueryMaker().keyword("*").end();
  query.setOffset(0);
  query.setLimit(0);
  query.setFacetExtension(true);
  WikittyQueryResult<String> result = wikittyClient.findAllByQuery(query);
  Assert.assertEquals(1, result.getFacetNames().size());
  //TODO echatellier 20120112 : revue this code
  //Assert.assertNotNull(result.getFacets().get(Element.EXTENSION));
  // is more convenient, but wont work
  Assert.assertNotNull(result.getFacets().get(Element.EXTENSION.getValue()));
}

@Test
public void testSearchFacetSingleField() throws Exception {
  importBooks();
  WikittyQuery query = new WikittyQueryMaker().exteq(Product.EXT_PRODUCT).end();
  query.setLimit(0);
  query.addFacetField(Product.ELEMENT_FIELD_PRODUCT_CATEGORY);
  query.setFacetSort(FacetSortType.count);
  WikittyQueryResult<String> result = wikittyClient.findAllByQuery(query);
  // les resultats sont répartit en 4 categories
  Assert.assertEquals(4, result.getTopic(Product.ELEMENT_FIELD_PRODUCT_CATEGORY).size());
  Assert.assertEquals(10, result.getTopic(Product.ELEMENT_FIELD_PRODUCT_CATEGORY).get(0).getCount());
  Assert.assertEquals(3, result.getTopic(Product.ELEMENT_FIELD_PRODUCT_CATEGORY).get(1).getCount());
  Assert.assertEquals(1, result.getTopic(Product.ELEMENT_FIELD_PRODUCT_CATEGORY).get(2).getCount());
  Assert.assertEquals(1, result.getTopic(Product.ELEMENT_FIELD_PRODUCT_CATEGORY).get(3).getCount());
}

  .select(Product.ELEMENT_FIELD_PRODUCT_PRICE)
  .exteq(Product.EXT_PRODUCT).end();
query1.setSortAscending(Product.ELEMENT_FIELD_PRODUCT_PRICE);
query1.setOffset(0);
query1.setLimit(2);
WikittyQueryResult<Double> results1 = wikittyClient.findAllByQuery(Double.class, query1);
Assert.assertEquals(17, results1.getTotalResult());
query1.setOffset(0);
query1.setLimit(0);
results1 = wikittyClient.findAllByQuery(Double.class, query1);
Assert.assertEquals(17, results1.getTotalResult());

if (q.isSelectQuery()) {
  queriesWhere.add(q.getWhereQuery());
} else {
  queriesWhere.add(q);
if (query.isSelectQuery()) {
  List<Map<String, Object>> values = new ArrayList<Map<String, Object>>(wikittyId.size());
  Select select = (Select)query.getCondition();
  selectFusion = select.getFunction().call(query, values);
if (query.isSelectQuery()) {

public Map<String, List<FacetTopic>> getFacets() {
  Map<String, List<FacetTopic>> result = new HashMap<String, List<FacetTopic>>();
  for (String facetName : topic.keySet()) {
    List<FacetTopic> list = new ArrayList<FacetTopic>();
    Multiset b = topic.get(facetName);
    for (Object topicName : b.elementSet()) {
      int count = b.count(topicName);
      // pour ajouter le topic il faut un minimum indique dans la query
      if (count >= query.getFacetMinCount()) {
        FacetTopic ft = new FacetTopic(facetName, String.valueOf(topicName), count);
        list.add(ft);
      }
    }
    // on re-tri si besoin, sinon l'ordre par defaut est sur la valeur des topics
    if (query.getFacetSort() == FacetSortType.count) {
      Collections.sort(list, query.getFacetSort().compartor);
    }
    // ... et on en prend que le nombre demande
    if (list.size() > query.getFacetLimit()) {
      list = list.subList(0, query.getFacetLimit());
    }
    result.put(facetName, list);
  }
  return result;
}

.eq(WikittyToken.ELEMENT_FIELD_WIKITTYTOKEN_USER, userId)
.end()
.setLimit(1);