Author: bpoussin Date: 2011-12-30 15:32:17 +0100 (Fri, 30 Dec 2011) New Revision: 1267 Url: http://nuiton.org/repositories/revision/wikitty/1267 Log: Evolution #1863: Create new query api with visitor and better implementation Evolution #1864: Add query langage syntaxe Implantation du WikittyQueryVisitorToSolr Tout compile et tous les tests repassent, mais il reste encore du travail :) Added: trunk/wikitty-solr/src/main/java/org/nuiton/wikitty/storage/solr/ElementModifier.java Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyClient.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/WikittyQueryVisitor.java trunk/wikitty-solr/src/main/java/org/nuiton/wikitty/storage/solr/FieldModifier.java trunk/wikitty-solr/src/main/java/org/nuiton/wikitty/storage/solr/WikittyQueryVisitorToSolr.java trunk/wikitty-solr/src/main/java/org/nuiton/wikitty/storage/solr/WikittySearchEngineSolr.java trunk/wikitty-solr/src/test/java/org/nuiton/wikitty/storage/solr/WikittySearchEngineSolrTest.java Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyClient.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyClient.java 2011-12-29 19:04:15 UTC (rev 1266) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyClient.java 2011-12-30 14:32:17 UTC (rev 1267) @@ -45,7 +45,10 @@ * into business objects used by applications. * * It also manage {@link #securityToken} for {@link org.nuiton.wikitty.services.WikittyServiceSecurity}. - * + * + * All method that need {@link #securityToken} and {@link org.nuiton.wikitty.services.WikittyServiceSecurity} + * must be in this class and not in {@link WikittyUtil} + * * @author poussin * @version $Revision$ * @since 3.3 Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/WikittyQueryVisitor.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/WikittyQueryVisitor.java 2011-12-29 19:04:15 UTC (rev 1266) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/WikittyQueryVisitor.java 2011-12-30 14:32:17 UTC (rev 1267) @@ -35,8 +35,10 @@ * q.accept(v); * v.getXXXX() * </pre> - * * + * ATTENTION les sous classes doivent avoir une visibilite public car sinon + * l'introspection n'arrive pas a executer les methods + * * @author poussin * @version $Revision$ * @since 3.3 @@ -201,7 +203,9 @@ try { downPolymorphic.invoke(this, new Object[] {object}); } catch (Exception eee) { - throw new WikittyException("Error during visitor call", eee); + throw new WikittyException(String.format( + "Error during visitor call method '%s'", + downPolymorphic), eee); } } } @@ -222,7 +226,9 @@ try { result = (Boolean)downPolymorphic.invoke(this, new Object[] {object}); } catch (Exception eee) { - throw new WikittyException("Error during visitor call", eee); + throw new WikittyException(String.format( + "Error during visitor call method '%s'", + downPolymorphic), eee); } } } @@ -245,7 +251,9 @@ try { result = (Boolean)downPolymorphic.invoke(this, new Object[] {object}); } catch (Exception eee) { - throw new WikittyException("Error during visitor call", eee); + throw new WikittyException(String.format( + "Error during visitor call method '%s'", + downPolymorphic), eee); } } } @@ -267,7 +275,9 @@ try { downPolymorphic.invoke(this, new Object[] {object, enterOrMiddleResult}); } catch (Exception eee) { - throw new WikittyException("Error during visitor call", eee); + throw new WikittyException(String.format( + "Error during visitor call method '%s'", + downPolymorphic), eee); } } } Added: trunk/wikitty-solr/src/main/java/org/nuiton/wikitty/storage/solr/ElementModifier.java =================================================================== --- trunk/wikitty-solr/src/main/java/org/nuiton/wikitty/storage/solr/ElementModifier.java (rev 0) +++ trunk/wikitty-solr/src/main/java/org/nuiton/wikitty/storage/solr/ElementModifier.java 2011-12-30 14:32:17 UTC (rev 1267) @@ -0,0 +1,172 @@ +package org.nuiton.wikitty.storage.solr; + +import org.apache.commons.lang.ClassUtils; +import org.apache.commons.lang.StringUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyUtil; +import org.nuiton.wikitty.entities.FieldType; +import org.nuiton.wikitty.entities.FieldType.TYPE; +import org.nuiton.wikitty.entities.WikittyExtension; +import org.nuiton.wikitty.query.conditions.Element; +import org.nuiton.wikitty.query.conditions.ElementExtension; +import org.nuiton.wikitty.query.conditions.ElementField; +import org.nuiton.wikitty.query.conditions.ElementId; +import org.nuiton.wikitty.services.WikittyTransaction; +import org.nuiton.wikitty.storage.WikittyExtensionStorage; + +import static org.nuiton.wikitty.storage.solr.WikittySolrConstant.*; + +/** + * Converti la valeur des objects de type {@link Element} pour etre utilisable + * dans Solr + * + * @author poussin + * @version $Revision$ + * @since 3.3 + * + * Last update: $Date$ + * by : $Author$ + */ +public class ElementModifier { + + /** to use log facility, just put in your code: log.info(\"...\"); */ + static private Log log = LogFactory.getLog(ElementModifier.class); + + protected WikittyExtensionStorage extensionStorage; + + public ElementModifier(WikittyExtensionStorage extensionStorage) { + this.extensionStorage = extensionStorage; + } + + /** + * Different cas d'entree + * <li> monext.monfield on recherche sur un champs, son type est retrouve dans la base + * <li> monext.monfield.NUMERIC le type n'est pas pris en compte, car le champs + * est complement renseigne et donc on va recherche dans la base son type + * <li> *.monfield = recherche fulltext car aucun type n'est indique + * <li> *.monfield.NUMERIC recheche en utilise le type demande si on + * final 'monfield' n'est pas de ce type alors on ne retrouvera rien car + * on recherchera sur un champs inexistant + * <li> *.* ou * = recherche fulltext + * + * @param tx + * @param element + * @return + */ + public String convertToSolr(WikittyTransaction tx, Element element) { + String result; + if (element instanceof ElementId) { + result = SOLR_ID; + } else if (element instanceof ElementExtension) { + result = SOLR_EXTENSIONS; + } else if (element instanceof ElementField) { + String[] searchField = + element.getValue().split(WikittyUtil.FQ_FIELD_NAME_SEPARATOR_REGEX); + + if (searchField.length >= 2) { + String extName = searchField[0]; + String fieldName = searchField[1]; + + if ("*".equals(extName) && "*".equals(fieldName)) { + result = SOLR_FULLTEXT; + } else if ("*".equals(extName)) { + result = SOLR_ALL_EXTENSIONS + + WikittyUtil.FQ_FIELD_NAME_SEPARATOR + fieldName; + + String modifier = ""; + // on recherche si le type a ete force + if (searchField.length >= 3) { + // On passe ici, si on indique dans le champs son type (ex: *.monfield.NUMERIC) + // utile pour force la recherche sur les bons champs lorsqu'on + // demande une recherche sur * == #all + String fieldNameType = searchField[2]; + TYPE type = FieldType.TYPE.valueOf(fieldNameType); + // Ajout du pattern solr pour discriminer le champs ex : _s, _dt, _w, ... + modifier = SolrUtil.getSolrFieldName("", type); + } + + if (StringUtils.isEmpty(modifier)) { + // si on arrive ici, c'est qu'on a pas reussi a calculer le + // modifier cela peut arriver par exemple pour + // #all ou le seul moyen d'avoir le type est qu'il soit donne + // dans le champs, sinon on ne peut pas le trouver + if (log.isDebugEnabled()) { + log.debug("Search on multi extentions (*) without field" + + " type, fallback search in fulltext"); + } + result = SOLR_FULLTEXT_ALL_EXTENSIONS + + WikittyUtil.FQ_FIELD_NAME_SEPARATOR + fieldName; + } else { + result += modifier; + } + + } else if ("*".equals(fieldName)) { + // on doit recherche sur tout les champs de cette extension + // en fait cela revient a faire une recherche fulltext avec + // une 2eme condition sur le type d'extension + // Il ne faut donc pas le gere comme ca, on previent via + // une exception qui l'explique + throw new WikittyException( + "To search on all field of one extension, you must" + + " use to condition, one on extension type, other" + + " in fulltext '*.*' with the wanted constraint"); + } else { + result = extName + WikittyUtil.FQ_FIELD_NAME_SEPARATOR + fieldName; + + // Ajout du pattern solr pour discriminer le champs ex : _s, _sm, _wm ... + // Search type of field in extension + String version = + extensionStorage.getLastVersion(tx, extName); + if (version != null) { // not valid extension if version == null + WikittyExtension ext = extensionStorage.restore( + tx, extName, version); + FieldType fieldType = ext.getFieldType(fieldName); + if (log.isDebugEnabled()) { + log.debug(ext.toDefinition() + " for " + fieldName); + } + if (fieldType != null) { // type can be null if extension version differ + TYPE type = fieldType.getType(); + result = SolrUtil.getSolrFieldName(result, type); + } else { + throw new WikittyException(String.format( + "Can't find field '%s' in extension '%s'" + + " with definition: %s", + fieldName, ext.getId(), ext.toDefinition())); + } + } else { + throw new WikittyException(String.format( + "Can't find extension '%s'", extName)); + } + } + } else if (searchField.length >= 1 && "*".equals(searchField[0])) { + result = SOLR_FULLTEXT; + } else { + throw new WikittyException("Empty field name is unsupported"); + } + } else { + throw new WikittyException(String.format( + "Unsupported Element type '%s'", + ClassUtils.getShortCanonicalName(element, "null"))); + } + + return result; + } + + public String convertToField(String solrName) { + String fieldName = solrName.replaceAll( + "(" + SUFFIX_BINARY + "$)" + + "|(" + SUFFIX_BOOLEAN + "$)" + + "|(" + SUFFIX_DATE + "$)" + + "|(" + SUFFIX_STRING + "$)" + + "|(" + SUFFIX_WIKITTY + "$)" + + "|(" + SUFFIX_NUMERIC + "$)" + + "|(" + SUFFIX_SORTABLE + "$)" + , ""); + if (SOLR_EXTENSIONS.equals(fieldName)) { + fieldName = new ElementExtension().getValue(); + } + return fieldName; + } +} Modified: trunk/wikitty-solr/src/main/java/org/nuiton/wikitty/storage/solr/FieldModifier.java =================================================================== --- trunk/wikitty-solr/src/main/java/org/nuiton/wikitty/storage/solr/FieldModifier.java 2011-12-29 19:04:15 UTC (rev 1266) +++ trunk/wikitty-solr/src/main/java/org/nuiton/wikitty/storage/solr/FieldModifier.java 2011-12-30 14:32:17 UTC (rev 1267) @@ -44,7 +44,9 @@ * * Last update: $Date$ * by : $Author$ + * @deprecated since 3.3 use new {@link ElementModifier} with new query API */ +@Deprecated public class FieldModifier { /** to use log facility, just put in your code: log.info(\"...\"); */ Modified: trunk/wikitty-solr/src/main/java/org/nuiton/wikitty/storage/solr/WikittyQueryVisitorToSolr.java =================================================================== --- trunk/wikitty-solr/src/main/java/org/nuiton/wikitty/storage/solr/WikittyQueryVisitorToSolr.java 2011-12-29 19:04:15 UTC (rev 1266) +++ trunk/wikitty-solr/src/main/java/org/nuiton/wikitty/storage/solr/WikittyQueryVisitorToSolr.java 2011-12-30 14:32:17 UTC (rev 1267) @@ -1,15 +1,18 @@ package org.nuiton.wikitty.storage.solr; +import org.apache.commons.lang.StringEscapeUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.apache.solr.client.solrj.SolrServer; +import org.nuiton.wikitty.WikittyException; import org.nuiton.wikitty.query.WikittyQuery; +import org.nuiton.wikitty.query.WikittyQueryResult; import org.nuiton.wikitty.query.WikittyQueryVisitor; import org.nuiton.wikitty.query.conditions.And; import org.nuiton.wikitty.query.conditions.Between; import org.nuiton.wikitty.query.conditions.Condition; import org.nuiton.wikitty.query.conditions.ContainsAll; import org.nuiton.wikitty.query.conditions.ContainsOne; +import org.nuiton.wikitty.query.conditions.Element; import org.nuiton.wikitty.query.conditions.Equals; import org.nuiton.wikitty.query.conditions.False; import org.nuiton.wikitty.query.conditions.Greater; @@ -26,6 +29,7 @@ import org.nuiton.wikitty.query.conditions.Or; import org.nuiton.wikitty.query.conditions.True; import org.nuiton.wikitty.query.conditions.Unlike; +import org.nuiton.wikitty.services.WikittyTransaction; /** * Converti une {@link Condition} en une requete Solr, une fois la condition @@ -41,13 +45,14 @@ * Last update: $Date$ * by : $Author$ */ -class WikittyQueryVisitorToSolr extends WikittyQueryVisitor { +public class WikittyQueryVisitorToSolr extends WikittyQueryVisitor { /** to use log facility, just put in your code: log.info(\"...\"); */ static private Log log = LogFactory.getLog(WikittyQueryVisitorToSolr.class); - protected SolrServer solrServer; - protected FieldModifier fieldModifier; + protected WikittyTransaction tx; + protected WikittySearchEngineSolr solrServer; + protected ElementModifier elementModifier; protected String solrQuery = ""; @@ -55,168 +60,237 @@ return solrQuery; } - public WikittyQueryVisitorToSolr(SolrServer solrServer, FieldModifier fieldModifier) { + public WikittyQueryVisitorToSolr(WikittyTransaction tx, + WikittySearchEngineSolr solrServer, ElementModifier elementModifier) { + this.tx = tx; this.solrServer = solrServer; - this.fieldModifier = fieldModifier; + this.elementModifier = elementModifier; } + private String element2solr(Element element) { + String result = elementModifier.convertToSolr(tx, element); + return result; + } + + private String value2solr(String value) { + String result; + if (value != null) { + result = "\"" + StringEscapeUtils.escapeJava(value) + "\""; + } else { + throw new WikittyException("Parse error, value must be not empty"); + } + return result; + } + @Override public boolean visitEnter(WikittyQuery o) { - throw new UnsupportedOperationException("Not supported yet."); + // do nothing + return true; } @Override public void visitLeave(WikittyQuery o, boolean enterOrMiddleResult) { - throw new UnsupportedOperationException("Not supported yet."); + // do nothing } @Override public boolean visitEnter(And o) { - throw new UnsupportedOperationException("Not supported yet."); + solrQuery += "("; + return true; } @Override public boolean visitMiddle(And o) { - throw new UnsupportedOperationException("Not supported yet."); + solrQuery += " AND "; + return true; } @Override - public void visitLeave(And o, boolean enterOrMiddleResult) { - throw new UnsupportedOperationException("Not supported yet."); + public void visitLeave(And o, boolean enterResult) { + solrQuery += ")"; } @Override public boolean visitEnter(Or o) { - throw new UnsupportedOperationException("Not supported yet."); + solrQuery += "("; + return true; } @Override public boolean visitMiddle(Or o) { - throw new UnsupportedOperationException("Not supported yet."); + solrQuery += " OR "; + return true; } @Override - public void visitLeave(Or o, boolean enterOrMiddleResult) { - throw new UnsupportedOperationException("Not supported yet."); + public void visitLeave(Or o, boolean enterResult) { + solrQuery += ")"; } @Override public boolean visitEnter(Join o) { - throw new UnsupportedOperationException("Not supported yet."); + WikittyQuery q = new WikittyQuery(o.getSubCondition()).setLimit(Integer.MAX_VALUE); + WikittyQueryResult<String> result = solrServer.findAllByQuery(tx, q); + + solrQuery += element2solr(o.getElement()) + + ":("; + String sep = ""; + for(String e : result) { + solrQuery += sep + value2solr(e); + sep = " OR "; + } + solrQuery += ")"; + return false; } @Override - public void visitLeave(Join o, boolean enterOrMiddleResult) { - throw new UnsupportedOperationException("Not supported yet."); + public void visitLeave(Join o, boolean enterResult) { + // do nothing } @Override public boolean visitEnter(Not o) { - throw new UnsupportedOperationException("Not supported yet."); + solrQuery += "NOT("; + return true; } @Override - public void visitLeave(Not o, boolean enterOrMiddleResult) { - throw new UnsupportedOperationException("Not supported yet."); + public void visitLeave(Not o, boolean enterResult) { + solrQuery += ")"; } @Override public void visit(Between o) { - throw new UnsupportedOperationException("Not supported yet."); + solrQuery += element2solr(o.getElement()) + + ":[" + value2solr(o.getMin()) + " TO " + value2solr(o.getMax()) + "]"; } @Override public void visit(ContainsAll o) { - throw new UnsupportedOperationException("Not supported yet."); + solrQuery += element2solr(o.getElement()) + + ":("; + String sep = ""; + for(String e : o.getValues()) { + solrQuery += sep + value2solr(e); + sep = " AND "; + } + solrQuery += ")"; } @Override public void visit(ContainsOne o) { - throw new UnsupportedOperationException("Not supported yet."); + solrQuery += element2solr(o.getElement()) + + ":("; + String sep = ""; + for(String e : o.getValues()) { + solrQuery += sep + value2solr(e); + sep = " OR "; + } + solrQuery += ")"; } @Override public void visit(Equals o) { - throw new UnsupportedOperationException("Not supported yet."); + solrQuery += element2solr(o.getElement()) + + ":" + value2solr(o.getValue()); } @Override public void visit(NotEquals o) { - throw new UnsupportedOperationException("Not supported yet."); + solrQuery += "-" + element2solr(o.getElement()) + + ":" + value2solr(o.getValue()); } @Override - public void visit(False o) { - throw new UnsupportedOperationException("Not supported yet."); + public void visit(True o) { + solrQuery += "( *:* )"; } @Override - public void visit(True o) { - throw new UnsupportedOperationException("Not supported yet."); + public void visit(False o) { + solrQuery += "( *:* - *:* )"; } @Override public void visit(Greater o) { - throw new UnsupportedOperationException("Not supported yet."); + solrQuery += element2solr(o.getElement()) + + ":{" + value2solr(o.getValue()) + " TO *}"; } @Override public void visit(GreaterOrEquals o) { - throw new UnsupportedOperationException("Not supported yet."); + solrQuery += element2solr(o.getElement()) + + ":[" + value2solr(o.getValue()) + " TO *]"; } @Override public void visit(Keyword o) { - throw new UnsupportedOperationException("Not supported yet."); + solrQuery += value2solr(o.getValue()); } @Override public void visit(Less o) { - throw new UnsupportedOperationException("Not supported yet."); + solrQuery += element2solr(o.getElement()) + + ":{* TO " + value2solr(o.getValue()) + "}"; } @Override public void visit(LessOrEquals o) { - throw new UnsupportedOperationException("Not supported yet."); + solrQuery += element2solr(o.getElement()) + + ":[* TO " + value2solr(o.getValue()) + "]"; } @Override public void visit(Like o) { - throw new UnsupportedOperationException("Not supported yet."); + String element2solr = element2solr(o.getElement()); + if (element2solr.endsWith(WikittySolrConstant.SUFFIX_STRING)) { // is string + // FIXME poussin 20111230 check la config solr et peut etre utiliser le lowercase ? + element2solr += WikittySolrConstant.SUFFIX_STRING_FULLTEXT; + } + + solrQuery += element2solr + ":" + value2solr(o.getValue()); } @Override public void visit(Unlike o) { - throw new UnsupportedOperationException("Not supported yet."); + String element2solr = element2solr(o.getElement()); + if (element2solr.endsWith(WikittySolrConstant.SUFFIX_STRING)) { // is string + // FIXME poussin 20111230 check la config solr et peut etre utiliser le lowercase ? + element2solr += WikittySolrConstant.SUFFIX_STRING_FULLTEXT; + } + + solrQuery += "-" + element2solr + ":" + value2solr(o.getValue()); } @Override public void visit(Null o) { - throw new UnsupportedOperationException("Not supported yet."); + solrQuery += WikittySolrConstant.SOLR_NULL_FIELD + + o.getElement().getValue() + ":true"; } @Override public void visit(NotNull o) { - throw new UnsupportedOperationException("Not supported yet."); + solrQuery += WikittySolrConstant.SOLR_NULL_FIELD + + o.getElement().getValue() + ":false"; } @Override public void defaultVisit(Object o) { - throw new UnsupportedOperationException("Not supported yet."); + throw new UnsupportedOperationException("Not supported:" + o.getClass()); } @Override public boolean defaultVisitEnter(Object o) { - throw new UnsupportedOperationException("Not supported yet."); + throw new UnsupportedOperationException("Not supported:" + o.getClass()); } @Override public boolean defaultVisitMiddle(Object o) { - throw new UnsupportedOperationException("Not supported yet."); + throw new UnsupportedOperationException("Not supported:" + o.getClass()); } @Override - public void defaultVisitLeave(Object o, boolean enterOrMiddleResult) { - throw new UnsupportedOperationException("Not supported yet."); + public void defaultVisitLeave(Object o, boolean enterResult) { + throw new UnsupportedOperationException("Not supported:" + o.getClass()); } } Modified: trunk/wikitty-solr/src/main/java/org/nuiton/wikitty/storage/solr/WikittySearchEngineSolr.java =================================================================== --- trunk/wikitty-solr/src/main/java/org/nuiton/wikitty/storage/solr/WikittySearchEngineSolr.java 2011-12-29 19:04:15 UTC (rev 1266) +++ trunk/wikitty-solr/src/main/java/org/nuiton/wikitty/storage/solr/WikittySearchEngineSolr.java 2011-12-30 14:32:17 UTC (rev 1267) @@ -93,8 +93,12 @@ protected SolrServer solrServer; /** Field modifier use to transform to solr format */ + @Deprecated protected FieldModifier fieldModifier; + /** Field modifier use to transform to solr format */ + protected ElementModifier elementModifier; + /** JTA resource */ protected SolrResource solrResource; @@ -144,6 +148,7 @@ solrServer = new EmbeddedSolrServer(solrCore, ""); fieldModifier = new FieldModifier(extensionStorage); + elementModifier = new ElementModifier(extensionStorage); solrResource = new SolrResource(solrServer); } catch (Exception eee) { @@ -651,7 +656,8 @@ public WikittyQueryResult<String> findAllByQuery(WikittyTransaction transaction, WikittyQuery query) { try { // Create querySolr - WikittyQueryVisitorToSolr v = new WikittyQueryVisitorToSolr(solrServer, fieldModifier); + WikittyQueryVisitorToSolr v = new WikittyQueryVisitorToSolr( + transaction, this, elementModifier); query.getCondition().accept(v); String queryString = v.getSolrQuery(); SolrQuery querySolr = new SolrQuery(SOLR_QUERY_PARSER + queryString); @@ -725,7 +731,8 @@ // query facetisation if (facetQuery != null) { for (FacetQuery facet : facetQuery) { - v = new WikittyQueryVisitorToSolr(solrServer, fieldModifier); + v = new WikittyQueryVisitorToSolr( + transaction, this, elementModifier); facet.getCondition().accept(v); String queryFacet = v.getSolrQuery(); facetQueryToName.put(queryFacet, facet.getName()); @@ -850,7 +857,8 @@ // on a dans treeSearch uniquement le noeud passe en parametre // et ses enfants jusqu'a la profondeur demandee // Create querySolr - WikittyQueryVisitorToSolr v = new WikittyQueryVisitorToSolr(solrServer, fieldModifier); + WikittyQueryVisitorToSolr v = new WikittyQueryVisitorToSolr( + transaction, this, elementModifier); treeQuery.getCondition().accept(v); String queryString = v.getSolrQuery(); SolrQuery querySolr = new SolrQuery(SOLR_QUERY_PARSER + queryString); Modified: trunk/wikitty-solr/src/test/java/org/nuiton/wikitty/storage/solr/WikittySearchEngineSolrTest.java =================================================================== --- trunk/wikitty-solr/src/test/java/org/nuiton/wikitty/storage/solr/WikittySearchEngineSolrTest.java 2011-12-29 19:04:15 UTC (rev 1266) +++ trunk/wikitty-solr/src/test/java/org/nuiton/wikitty/storage/solr/WikittySearchEngineSolrTest.java 2011-12-30 14:32:17 UTC (rev 1267) @@ -198,7 +198,7 @@ TreeNodeResult<String> treeNodeResult = ws.getSearchEngine().findAllChildrenCount( - null, root.getId(), 0, true, null); + null, root.getId(), 0, true, (Criteria)null); int val = treeNodeResult.getAttCount(); // Integer val = ws.getSearchEngine().findNodeCount(null, root, null); Assert.assertEquals(12, val); @@ -207,7 +207,7 @@ // Map<String, Integer> children = ws.getSearchEngine().findAllChildrenCount(null, root, null); TreeNodeResult<String> children = ws.getSearchEngine().findAllChildrenCount( - null, root.getId(), 1, true, null); + null, root.getId(), 1, true, (Criteria)null); if (log.isDebugEnabled()) { log.debug("Children : " + children); }