Author: bpoussin Date: 2013-02-21 15:28:35 +0100 (Thu, 21 Feb 2013) New Revision: 1531 Url: http://nuiton.org/projects/wikitty/repository/revisions/1531 Log: debuggage et am?\195?\169lioration des nouveaux select Added: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/ListObjectOrMap.java Removed: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/storage/WikittySearchEngineHelper.java Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyClient.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyUtil.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/WikittyQueryMakerAbstract.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/WikittyQueryVisitorCopy.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionAvg.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionCount.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionFieldValue.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionFusion.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionMax.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionMin.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionSum.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionValue.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/WikittyQueryFunction.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/WikittyQueryFunctionWrapper.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/storage/WikittySearchEngineInMemory.java trunk/wikitty-solr/src/main/java/org/nuiton/wikitty/storage/solr/WikittySearchEngineSolr.java Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyClient.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyClient.java 2013-02-20 11:31:06 UTC (rev 1530) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyClient.java 2013-02-21 14:28:35 UTC (rev 1531) @@ -60,6 +60,7 @@ import org.nuiton.wikitty.entities.WikittyTokenHelper; import org.nuiton.wikitty.entities.WikittyTypes; import org.nuiton.wikitty.entities.WikittyUser; +import org.nuiton.wikitty.query.ListObjectOrMap; import org.nuiton.wikitty.query.WikittyQuery; import org.nuiton.wikitty.query.WikittyQueryMaker; import org.nuiton.wikitty.query.WikittyQueryResult; @@ -738,8 +739,38 @@ */ protected <E> List<WikittyQueryResult<E>> findAllByQuery( Class<E> clazz, List<WikittyQuery> queries, boolean limitToFirst) { + List<WikittyQueryResult<Map<String, E>>> tmp = + findAllByQueryAsMap(clazz, queries, limitToFirst); + + List<WikittyQueryResult<E>> result = new ArrayList<WikittyQueryResult<E>>(tmp.size()); + for (WikittyQueryResult p : tmp) { + result.add(p.convertMapToSimple()); +// result.add(castTo(clazz, p)); + } + + return result; + } + + /** + * Cette method doit etre l'unique methode finalement utilise par toutes + * les methodes find avec un cast vers clazz + * + * Search object that correspond to criteria and that have all extension + * needed by BusinessEntity (clazz), if clazz is BusinessEntity class. + * If one criteria is empty, find all extensions + * for this criteria else if criteria is null return null. + * + * @param <E> object type + * Can be Wikitty, BusinessEntity, String, Date, Number (returned is BigDecimal), Boolean, byte[] + * @param clazz entity class, can be null for no conversion + * @param queries criterias + * @param limitToFirst if true limit result to first result (first = 0, limit = 1) + * @return paged result + */ + protected <E> List<WikittyQueryResult<Map<String, E>>> findAllByQueryAsMap( + Class<E> clazz, List<WikittyQuery> queries, boolean limitToFirst) { long start = TimeLog.getTime(); - List<WikittyQueryResult<E>> result = null; + List<WikittyQueryResult<Map<String, E>>> result = null; List<WikittyQuery> serviceQueries; if (queries != null) { if (clazz != null && BusinessEntity.class.isAssignableFrom(clazz)) { @@ -817,12 +848,12 @@ List<WikittyQueryResult<Map<String, Object>>> pagedResult = findAllByQueryAsMap(serviceQueries); - result = new ArrayList<WikittyQueryResult<E>>(pagedResult.size()); - for (WikittyQueryResult<Map<String, Object>> p : pagedResult) { - result.add((WikittyQueryResult<E>)castTo(clazz, p)); + result = new ArrayList<WikittyQueryResult<Map<String, E>>>(pagedResult.size()); + for (WikittyQueryResult p : pagedResult) { + result.add((WikittyQueryResult<Map<String, E>>)castToMap(clazz, p)); } } - timeLog.log(start, "findAllByQuery<E>(List, limitToFirst)"); + timeLog.log(start, "findAllByQuery<Map<String, E>>(List, limitToFirst)"); return result; } @@ -1074,9 +1105,27 @@ } } timeLog.log(start, "findByQuery(List)"); - return result; + return result; } + public <E> List<Map<String, E>> findByQueryAsMap(Class<E> clazz, List<WikittyQuery> query) { + long start = TimeLog.getTime(); + List<Map<String, E>> result = null; + if (query != null) { + List<WikittyQueryResult<Map<String, E>>> tmp = findAllByQueryAsMap(clazz, query, true); + result = new ArrayList<Map<String, E>>(tmp.size()); + for (WikittyQueryResult<Map<String, E>> wqr : tmp) { + if (wqr.size() == 0) { + result.add(null); + } else { + result.add(wqr.peek()); + } + } + } + timeLog.log(start, "findByQuery(List)"); + return result; + } + public String findByQuery(WikittyQuery query) { long start = TimeLog.getTime(); String result = null; @@ -1094,9 +1143,19 @@ result = findByQueryAsMap(Collections.singletonList(query)).get(0); } timeLog.log(start, "findByQuery(One)"); - return result; + return result; } + public <E> Map<String, E> findByQueryAsMap(Class<E> clazz, WikittyQuery query) { + long start = TimeLog.getTime(); + Map<String, E> result = null; + if (query != null) { + result = findByQueryAsMap(clazz, Collections.singletonList(query)).get(0); + } + timeLog.log(start, "findByQuery(One)"); + return result; + } + public String[] findByQuery( WikittyQuery q1, WikittyQuery q2, WikittyQuery... otherQueries) { long start = TimeLog.getTime(); @@ -1699,180 +1758,213 @@ } - /** - * Convert all objects in list parameter to the wanted type and return - * new List. - * For business object transformation, if some - * result don't have the right extension (clazz) this extension is - * automatically added. - * - * If possible this method don't instanciated new Object. If e is Wikitty - * and wanted target is Wikitty a simple cast is done. - * - * @param target to cast into. - * Can be Wikitty, BusinessEntity, String, Date, Number (returned is BigDecimal), Boolean, byte[] - * @param objects objects to convert - * @return List objects in right class or Exception. - * if conversion is impossible - * @since 3.4 - */ - public <E, F> List<E> castTo(Class<E> target, List<F> objects) { - List<E> result; +// /** +// * Convert all objects in list parameter to the wanted type and return +// * new List. +// * For business object transformation, if some +// * result don't have the right extension (clazz) this extension is +// * automatically added. +// * +// * If possible this method don't instanciated new Object. If e is Wikitty +// * and wanted target is Wikitty a simple cast is done. +// * +// * @param target to cast into. +// * Can be Wikitty, BusinessEntity, String, Date, Number (returned is BigDecimal), Boolean, byte[] +// * @param objects objects to convert +// * @return List objects in right class or Exception. +// * if conversion is impossible +// * @since 3.4 +// */ +// public <E, F> List<E> castTo(Class<E> target, List<F> objects) { +// List<E> result; +// +// if (objects == null) { +// result = null; +// } else if (target.isAssignableFrom(Object.class)) { +// // on demande la conversion en Object, donc aucune conversion +// result = new ArrayList<E>((List<E>)objects); +// }else if (objects.size() == 0) { +// // on ne fait rien on met juste une nouvelle liste vide +// result = new ArrayList<E>(); +// } else if (Wikitty.class.isAssignableFrom(target)) { +// // On veut des Wikitties en sortie +// +// Object first = objects.get(0); +// if (first instanceof Wikitty) { +// // W, rien a faire +// result = (List<E>)objects; +// } else if (first instanceof BusinessEntityImpl) { +// // BusinessEntityImpl, il faut recuperer les wikitty +// result = new ArrayList<E>(objects.size()); +// for (BusinessEntityImpl e : (List<BusinessEntityImpl>)objects) { +// result.add((E)e.getWikitty()); +// } +// } else if (first instanceof BusinessEntity) { +// // BusinessEntity, il faut faire un restore puis remettre la +// // valeur des champs dans les wikitties recuperes +// +// // on collecte tous les ids +// List<String> ids = new ArrayList(objects.size()); +// for (BusinessEntity e : (List<BusinessEntity>)objects) { +// ids.add(e.getWikittyId()); +// } +// +// List<BusinessEntity> business = (List<BusinessEntity>)objects; +// List<Wikitty> wikitties = restore(ids); +// Class entityClass = first.getClass(); +// +// result = (List<E>)createWikittyFromBusinessEntity(entityClass, business, wikitties); +// } else if (first instanceof String) { +// // String, il faut faire un restore +// // le queryResult courant contient des Ids +// // Si ce n'est pas le cas, ca veut dire que le developpeur utilisant +// // ce queryResult ne sait pas ce qu'il fait :) +// List<String> ids = (List<String>) objects; +// result = (List<E>)restore(ids); +// } else { +// throw new ClassCastException("WikittyQueryResult don't contains" +// + " object convertible to Wikitty" +// + " (accepted Wikitty, BusinessEntityImpl, String id) but not " +// + first.getClass()); +// } +// } else if (BusinessEntity.class.isAssignableFrom(target)) { +// // on commence par tout mettre en Wikitty, en utilisant le if du dessus +// List<Wikitty> resultTmp = castTo(Wikitty.class, objects); +// result = (List<E>)WikittyUtil.newInstance((Class<BusinessEntity>)target, resultTmp); +// } else if (Number.class.isAssignableFrom(target)) { +// result = new ArrayList<E>(objects.size()); +// for (Object o : objects) { +// BigDecimal v = WikittyUtil.toBigDecimal(o); +// Number n = WikittyUtil.toNumber(target, v); +// result.add((E)n); +// } +// } else if (Date.class.isAssignableFrom(target)) { +// result = new ArrayList<E>(objects.size()); +// for (Object o : objects) { +// Date v = WikittyUtil.toDate(o); +// result.add((E)v); +// } +// } else if (Boolean.class.isAssignableFrom(target)) { +// result = new ArrayList<E>(objects.size()); +// for (Object o : objects) { +// Boolean v = WikittyUtil.toBoolean(o); +// result.add((E)v); +// } +// } else if (byte[].class.isAssignableFrom(target)) { +// result = new ArrayList<E>(objects.size()); +// for (Object o : objects) { +// byte[] v = WikittyUtil.toBinary(o); +// result.add((E)v); +// } +// } else if (String.class.isAssignableFrom(target)) { +// result = new ArrayList<E>(objects.size()); +// for (Object o : objects) { +// String v = WikittyUtil.toString(o); +// result.add((E)v); +// } +// }else { +// throw new ClassCastException(String.format( +// "Object list don't contains" +// + " object convertible to %s" +// + " (accepted Wikitty, BusinessEntityImpl, String id, Date," +// + " BigDecimal, Boolean, byte[]) but not '%s'", +// target.getName(), objects.get(0).getClass())); +// } +// +// return result; +// } +// +// /** +// * Convert all objects in list parameter to the wanted type and return +// * new List. +// * For business object transformation, if some +// * result don't have the right extension (clazz) this extension is +// * automatically added. +// * +// * If possible this method don't instanciated new Object. If e is Wikitty +// * and wanted target is Wikitty a simple cast is done. +// * +// * @param target to cast into. +// * Can be Wikitty, BusinessEntity, String, Date, Number (returned is BigDecimal), Boolean, byte[] +// * @param objects objects to convert +// * @return List objects in right class or Exception. +// * if conversion is impossible +// * @since 3.4 +// */ +// public <E, F> List<Map<String, E>> castToMap(Class<E> target, List<Map> objects) { +// List<Map<String, E>> result; +// +// if (objects == null) { +// result = null; +// } else if (target.isAssignableFrom(Object.class)) { +// // on demande la conversion en Object, donc aucune conversion +// result = new ArrayList(objects); +// } else if (objects.size() == 0) { +// // on ne fait rien on met juste une nouvelle liste vide +// result = new ArrayList<Map<String, E>>(); +// } else { +// for (Map map : objects) { +// if (map != null) { +// Set<Map.Entry> s = map.entrySet(); +// for (Map.Entry entry : s) { +// Object value = entry.getValue(); +// if (Wikitty.class.isAssignableFrom(target)) { +// // On veut des Wikitties en sortie +// if (value == null) { +// // rien a faire +// } else if (value instanceof Wikitty) { +// // W, rien a faire +// } else if (value instanceof String) { +// // String, il faut faire un restore +// // le queryResult courant contient des Ids +// // Si ce n'est pas le cas, ca veut dire que le developpeur utilisant +// // ce queryResult ne sait pas ce qu'il fait :) +// entry.setValue((E)restore((String)value)); +// } else { +// throw new ClassCastException("WikittyQueryResult don't contains" +// + " object convertible to Wikitty" +// + " (accepted Wikitty, String id) but not " +// + value.getClass()); +// } +// } else if (BusinessEntity.class.isAssignableFrom(target)) { +// // on commence par tout mettre en Wikitty, en utilisant le if du dessus +// Wikitty resultTmp = castTo(Wikitty.class, value); +// E business = (E)WikittyUtil.newInstance((Class<BusinessEntity>)target, resultTmp); +// entry.setValue(business); +// } else if (Number.class.isAssignableFrom(target)) { +// BigDecimal v = WikittyUtil.toBigDecimal(value); +// Number n = WikittyUtil.toNumber(target, v); +// entry.setValue((E)n); +// } else if (Date.class.isAssignableFrom(target)) { +// Date v = WikittyUtil.toDate(value); +// entry.setValue((E)v); +// } else if (Boolean.class.isAssignableFrom(target)) { +// Boolean v = WikittyUtil.toBoolean(value); +// entry.setValue((E)v); +// } else if (byte[].class.isAssignableFrom(target)) { +// byte[] v = WikittyUtil.toBinary(value); +// entry.setValue((E)v); +// } else if (String.class.isAssignableFrom(target)) { +// String v = WikittyUtil.toString(value); +// entry.setValue((E)v); +// }else { +// throw new ClassCastException(String.format( +// "Object list don't contains" +// + " object convertible to %s" +// + " (accepted Wikitty, BusinessEntityImpl, String id, Date," +// + " BigDecimal, Boolean, byte[]) but not '%s'", +// target.getName(), objects.get(0).getClass())); +// } +// } +// } +// } +// // tous les objets ont ete converti, on force le cast +// result = (List)objects; +// } +// +// return result; +// } - if (objects == null) { - result = null; - } else if (target.isAssignableFrom(Object.class)) { - // on demande la conversion en Object, donc aucune conversion - result = new ArrayList<E>((List<E>)objects); - }else if (objects.size() == 0) { - // on ne fait rien on met juste une nouvelle liste vide - result = new ArrayList<E>(); - } else if (Wikitty.class.isAssignableFrom(target)) { - // On veut des Wikitties en sortie - - Object first = objects.get(0); - if (first instanceof Wikitty) { - // W, rien a faire - result = (List<E>)objects; - } else if (first instanceof BusinessEntityImpl) { - // BusinessEntityImpl, il faut recuperer les wikitty - result = new ArrayList<E>(objects.size()); - for (BusinessEntityImpl e : (List<BusinessEntityImpl>)objects) { - result.add((E)e.getWikitty()); - } - } else if (first instanceof BusinessEntity) { - // BusinessEntity, il faut faire un restore puis remettre la - // valeur des champs dans les wikitties recuperes - - // on collecte tous les ids - List<String> ids = new ArrayList(objects.size()); - for (BusinessEntity e : (List<BusinessEntity>)objects) { - ids.add(e.getWikittyId()); - } - - result = (List<E>)restore(ids); - - // on copie les champs des entities dans les wikitties recuperes - // try settings all fields except version - try { - // les entites a mettre dans les wikitties - BusinessEntity[] entities = objects.toArray(new BusinessEntity[objects.size()]); - // les wikitties qui seront les resultats - Wikitty[] wikitties = result.toArray(new Wikitty[result.size()]); - - //get all fields - Class entityClass = first.getClass(); - Field[] fields = entityClass.getDeclaredFields(); - - for(Field field:fields){ - //for each field that got WikittyField annotation - if (field.isAnnotationPresent(WikittyField.class)){ - - //get the attribute's wikitty fqn - WikittyField annotation = field.getAnnotation(WikittyField.class); - String fieldFQN = annotation.fqn(); - - //set the value - Method m = entityClass.getMethod("get" + StringUtils.capitalize(field.getName())); - - for(int i=0; i<entities.length; i++) { - if (wikitties[i] != null) { - // le wikitty peut etre null, par exemple a cause de la security - Object value = m.invoke(entities[i]); - wikitties[i].setFqField(fieldFQN, value); - } - } - } - } - //manually set version - for(int i=0; i<entities.length; i++) { - if (wikitties[i] != null) { - // le wikitty peut etre null, par exemple a cause de la security - wikitties[i].setWikittyVersion(entities[i].getWikittyVersion()); - } - } - } catch (Exception eee) { - throw new WikittyException("Could not transform entity to Wikitty", eee); - } - } else if (first instanceof String) { - // String, il faut faire un restore - // le queryResult courant contient des Ids - // Si ce n'est pas le cas, ca veut dire que le developpeur utilisant - // ce queryResult ne sait pas ce qu'il fait :) - List<String> ids = (List<String>) objects; - result = (List<E>)restore(ids); - } else { - throw new ClassCastException("WikittyQueryResult don't contains" - + " object convertible to Wikitty" - + " (accepted Wikitty, BusinessEntityImpl, String id) but not " - + first.getClass()); - } - } else if (BusinessEntity.class.isAssignableFrom(target)) { - // on commence par tout mettre en Wikitty, en utilisant le if du dessus - List<Wikitty> resultTmp = castTo(Wikitty.class, objects); - result = (List<E>)WikittyUtil.newInstance((Class<BusinessEntity>)target, resultTmp); - } else if (Number.class.isAssignableFrom(target)) { - result = new ArrayList<E>(objects.size()); - for (Object o : objects) { - BigDecimal v = WikittyUtil.toBigDecimal(o); - Number n = toNumber(target, v); - result.add((E)n); - } - } else if (Date.class.isAssignableFrom(target)) { - result = new ArrayList<E>(objects.size()); - for (Object o : objects) { - Date v = WikittyUtil.toDate(o); - result.add((E)v); - } - } else if (Boolean.class.isAssignableFrom(target)) { - result = new ArrayList<E>(objects.size()); - for (Object o : objects) { - Boolean v = WikittyUtil.toBoolean(o); - result.add((E)v); - } - } else if (byte[].class.isAssignableFrom(target)) { - result = new ArrayList<E>(objects.size()); - for (Object o : objects) { - byte[] v = WikittyUtil.toBinary(o); - result.add((E)v); - } - } else if (String.class.isAssignableFrom(target)) { - result = new ArrayList<E>(objects.size()); - for (Object o : objects) { - String v = WikittyUtil.toString(o); - result.add((E)v); - } - }else { - throw new ClassCastException(String.format( - "Object list don't contains" - + " object convertible to %s" - + " (accepted Wikitty, BusinessEntityImpl, String id, Date," - + " BigDecimal, Boolean, byte[]) but not '%s'", - target.getName(), objects.get(0).getClass())); - } - - return result; - } - - protected Number toNumber(Class target, BigDecimal v) { - Number result = v; - if (Byte.class.isAssignableFrom(target)) { - result = v.byteValue(); - } else if (Double.class.isAssignableFrom(target)) { - result = v.doubleValue(); - } else if (Float.class.isAssignableFrom(target)) { - result = v.floatValue(); - } else if (Integer.class.isAssignableFrom(target)) { - result = v.intValue(); - } else if (Long.class.isAssignableFrom(target)) { - result = v.longValue(); - } else if (Short.class.isAssignableFrom(target)) { - result = v.shortValue(); - } else if (BigInteger.class.isAssignableFrom(target)) { - result = v.toBigInteger(); - } - return result; - } /** * Convert e parameter to the wanted type and return it. * For business object transformation, if some @@ -1895,7 +1987,7 @@ if (e == null) { result = null; } else { - List<E> tmp = castTo(target, Collections.singletonList(e)); + List<E> tmp = castTo(target, WikittyUtil.singletonList(e)); result = tmp.get(0); } @@ -1937,4 +2029,185 @@ return result; } + /** + * Convert all result to the wanted type and return new WikittyQueryResult + * with this new result list. For business object transformation, if some + * result don't have the right extension (clazz) this extension is + * automatically added. + * + * @param queryResult result to convert + * @param target to cast into. + * Can be Wikitty, BusinessEntity, String, Date, Number (returned is BigDecimal), Boolean, byte[] + * @return new WikittyQueryResult with element in right class or Exception + * if conversion is impossible + */ + public <E> WikittyQueryResult<Map<String, E>> castToMap(Class<E> target, + WikittyQueryResult<Map> queryResult) { + WikittyQueryResult<Map<String, E>> result; + + long startTime = System.nanoTime(); + + List<Map<String, E>> castedResult = castToMap(target, queryResult.getAll()); + long estimatedTime = System.nanoTime() - startTime; + + result = new WikittyQueryResult<Map<String, E>>( + queryResult.getQueryName(), + queryResult.getOffset(), queryResult.getTotalResult(), + queryResult.getQueryString(), queryResult.getFacets(), + castedResult, + queryResult.getTimeQuery(), estimatedTime); + + return result; + } + + + + + public <O, N, E extends Map<String, O>, F extends Map<String, N>> List<E> castToMap(Class<O> target, List<F> objects) { + List result = castTo(target, objects); + return result; + } + + + public <E, F> List<E> castTo(Class<E> target, List<F> objects) { + List<E> result = (List<E>)objects; + + if (objects == null + || target == null + || objects.size() == 0 + // on demande la conversion en Object, donc aucune conversion + ||target.isAssignableFrom(Object.class)) { + // on ne fait rien + } else if (BusinessEntity.class.isAssignableFrom(target)) { + // on commence par tout mettre en Wikitty, en utilisant une autre regle + List<Wikitty> resultTmp = castTo(Wikitty.class, objects); + ListObjectOrMap list = new ListObjectOrMap(resultTmp); + // ensuite on cree les businessEntity + for (ListObjectOrMap.ListObjectOrMapIterator i = list.iter(); i.hasNext();) { + Wikitty o = (Wikitty)i.next(); + Object business = WikittyUtil.newInstance((Class<BusinessEntity>)target, o); + i.setValue(business); + } + } else { + ListObjectOrMap list = new ListObjectOrMap(objects); + // les ids a collecter et restorer, et en valeur si besoin le BusinessEntity associe + Map<String, ListObjectOrMap.Key> ids = new HashMap(); + + for (ListObjectOrMap.ListObjectOrMapIterator i = list.iter(); i.hasNext();) { + Object o = i.next(); + + if (Number.class.isAssignableFrom(target)) { + BigDecimal v = WikittyUtil.toBigDecimal(o); + Number n = WikittyUtil.toNumber(target, v); + i.setValue(n); + } else if (Date.class.isAssignableFrom(target)) { + Date v = WikittyUtil.toDate(o); + i.setValue(v); + } else if (Boolean.class.isAssignableFrom(target)) { + Boolean v = WikittyUtil.toBoolean(o); + i.setValue(v); + } else if (byte[].class.isAssignableFrom(target)) { + byte[] v = WikittyUtil.toBinary(o); + i.setValue(v); + } else if (String.class.isAssignableFrom(target)) { + String v = WikittyUtil.toString(o); + i.setValue(v); + } else if (Wikitty.class.isAssignableFrom(target)) { + // On veut des Wikitties en sortie + + if (o instanceof Wikitty) { + // W, rien a faire + } else if (o instanceof BusinessEntityImpl) { + // BusinessEntityImpl, il faut recuperer les wikitties + i.setValue(((BusinessEntityImpl)o).getWikitty()); + } else if (o instanceof BusinessEntity) { + // on collecte tous les ids + String id = ((BusinessEntity)o).getWikittyId(); + ids.put(id, i.getKey()); + } else if (o instanceof String) { + // String, il faudra faire un restore + ids.put((String)o, i.getKey()); + } else { + throw new ClassCastException("WikittyQueryResult don't contains" + + " object convertible to Wikitty" + + " (accepted Wikitty, BusinessEntityImpl, String id) but not " + + o.getClass()); + } + } else { + throw new ClassCastException(String.format( + "Object list don't contains" + + " object convertible to %s" + + " (accepted Wikitty, BusinessEntityImpl, String id, Date," + + " BigDecimal, Boolean, byte[]) but not '%s'", + target.getName(), o.getClass())); + } + } + + if (!ids.isEmpty()) { + Set<Wikitty> wikitties = restore(ids.keySet()); + for (Wikitty w : wikitties) { + String id = w.getWikittyId(); + ListObjectOrMap.Key key = ids.get(id); + Object o = key.getValue(); + if (o instanceof BusinessEntity) { + // il faut mettre a jour le wikitty avec les champs de BusinessEntity + WikittyUtil.updateWikitty(w, (BusinessEntity)o); + } + key.setValue(w); + } + } + } + return result; + } + + + + + +// +// protected List<Wikitty> createWikittyFromBusinessEntity(Class entityClass, List<BusinessEntity> objects, List<Wikitty> w) { +// // on copie les champs des entities dans les wikitties recuperes +// // try settings all fields except version +// try { +// // les entites a mettre dans les wikitties +// BusinessEntity[] entities = objects.toArray(new BusinessEntity[objects.size()]); +// // les wikitties qui seront les resultats +// Wikitty[] wikitties = w.toArray(new Wikitty[w.size()]); +// +// //get all fields +// Field[] fields = entityClass.getDeclaredFields(); +// +// for(Field field:fields){ +// //for each field that got WikittyField annotation +// if (field.isAnnotationPresent(WikittyField.class)){ +// +// //get the attribute's wikitty fqn +// WikittyField annotation = field.getAnnotation(WikittyField.class); +// String fieldFQN = annotation.fqn(); +// +// //set the value +// Method m = entityClass.getMethod("get" + StringUtils.capitalize(field.getName())); +// +// for(int i=0; i<entities.length; i++) { +// if (wikitties[i] != null) { +// // le wikitty peut etre null, par exemple a cause de la security +// Object value = m.invoke(entities[i]); +// wikitties[i].setFqField(fieldFQN, value); +// } +// } +// } +// } +// //manually set version +// for(int i=0; i<entities.length; i++) { +// if (wikitties[i] != null) { +// // le wikitty peut etre null, par exemple a cause de la security +// wikitties[i].setWikittyVersion(entities[i].getWikittyVersion()); +// } +// } +// return w; +// } catch (Exception eee) { +// throw new WikittyException("Could not transform entity to Wikitty", eee); +// } +// +// } } Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyUtil.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyUtil.java 2013-02-20 11:31:06 UTC (rev 1530) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyUtil.java 2013-02-21 14:28:35 UTC (rev 1531) @@ -43,6 +43,7 @@ import org.nuiton.wikitty.services.WikittyServiceEnhanced; import java.lang.reflect.Constructor; import java.math.BigDecimal; +import java.math.BigInteger; import java.net.Inet4Address; import java.net.Inet6Address; import java.net.InetAddress; @@ -749,6 +750,35 @@ } /** + * Converti un BigDecimal en un nombre + * + * @param target la class du nombre + * @param v + * @return + */ + static public Number toNumber(Class target, BigDecimal v) { + Number result = v; + if (BigDecimal.class.isAssignableFrom(target)) { + result = v; + } else if (Byte.TYPE.isAssignableFrom(target) || Byte.class.isAssignableFrom(target)) { + result = v.byteValue(); + } else if (Double.TYPE.isAssignableFrom(target) || Double.class.isAssignableFrom(target)) { + result = v.doubleValue(); + } else if (Float.TYPE.isAssignableFrom(target) || Float.class.isAssignableFrom(target)) { + result = v.floatValue(); + } else if (Integer.TYPE.isAssignableFrom(target) || Integer.class.isAssignableFrom(target)) { + result = v.intValue(); + } else if (Long.TYPE.isAssignableFrom(target) || Long.class.isAssignableFrom(target)) { + result = v.longValue(); + } else if (Short.TYPE.isAssignableFrom(target) || Short.class.isAssignableFrom(target)) { + result = v.shortValue(); + } else if (BigInteger.class.isAssignableFrom(target)) { + result = v.toBigInteger(); + } + return result; + } + + /** * Convert object o for export CSV/XML. * * @param field field description @@ -1601,6 +1631,47 @@ static public WikittyDateConverter dateConverter = new WikittyDateConverter(); /** + * Met a jout les donnees d'un wikitty via les informations d'un BusinessEntity + * @param w le wikitty a mettre a jour (peut-etre null) + * @param be le business entity utilise pour mettre a jour le wikitty + */ + static public void updateWikitty(Wikitty w, BusinessEntity be) { + // le wikitty peut etre null, par exemple a cause de la security + if (w == null) { + return; + } + + // on copie les champs des entities dans les wikitties recuperes + // try settings all fields except version + try { + Class entityClass = be.getClass(); + //get all fields + Field[] fields = entityClass.getDeclaredFields(); + + for(Field field:fields){ + //for each field that got WikittyField annotation + if (field.isAnnotationPresent(WikittyField.class)){ + + //get the attribute's wikitty fqn + WikittyField annotation = field.getAnnotation(WikittyField.class); + String fieldFQN = annotation.fqn(); + + //set the value + Method m = entityClass.getMethod("get" + StringUtils.capitalize(field.getName())); + + Object value = m.invoke(be); + w.setFqField(fieldFQN, value); + } + } + //manually set version + w.setWikittyVersion(be.getWikittyVersion()); + } catch (Exception eee) { + throw new WikittyException("Could not transform entity to Wikitty", eee); + } + } + + + /** * Copy all properties (get/set) from source to destination, * except wikitty property * @@ -1681,4 +1752,32 @@ } } + /** + * Creation d'une map contenant une seule valeur. On utilise pas + * {@link Collections#singletonMap} car on ne peut plus changer la valeur + * alors qu'on en a besoin dans Wikitty, lorsqu'on converti des donnees + * + * @param k la cle + * @param v la valeur + * @return une nouvelle map avec 1 seul element et un load factor a 1 + */ + static public Map singletonMap(Object k, Object v) { + HashMap result = new HashMap(1, 1); + result.put(k, v); + return result; + } + + /** + * Creation d'une list contenant une seule valeur. On utilise pas + * {@link Collections#singletonList} car on ne peut plus changer la valeur + * alors qu'on en a besoin dans Wikitty, lorsqu'on converti des donnees + * + * @param o la valeur + * @return une nouvelle list avec 1 seul element et une taille initiale de 1 + */ + static public List singletonList(Object o) { + List result = new ArrayList(1); + result.add(o); + return result; + } } Added: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/ListObjectOrMap.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/ListObjectOrMap.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/ListObjectOrMap.java 2013-02-21 14:28:35 UTC (rev 1531) @@ -0,0 +1,321 @@ +package org.nuiton.wikitty.query; + + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.ListIterator; +import java.util.Map; +import java.util.Set; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +/** + * Encapsule une liste pour permettre une iteration et une modification facile + * des valeurs de cette listes. Les valeurs peuvent etre dans des maps, il est + * donc penible de parcourrir la liste, puis les maps, puis de modifier les + * valeurs de ces maps. La method {@link iter} retourne un iterator qui permet + * d'avance aussi bien dans la liste si celle-ci ne contient pas de Map ou dans + * les valeurs des Map si la liste est constituee de Map. + * Il est alors possible de recupere la valeur courante, modifier la valeur + * courante ou recuperer une Key qui permettra de mettre a jour l'element + * plus tard. Cette Class est surtout utilise pour la methode + * {@link WikittyClient#castTo} + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public class ListObjectOrMap implements List { + + /** to use log facility, just put in your code: log.info(\"...\"); */ + static private Log log = LogFactory.getLog(ListObjectOrMap.class); + + protected List list; + + public ListObjectOrMap() { + this.list = new ArrayList(); + } + + public ListObjectOrMap(List list) { + this.list = list; + } + + @Override + public String toString() { + return list.toString(); + } + + /** + * Ajoute une nouvelle map dans la liste avec les elements fournis en parametre + * @param key + * @param value + */ + public void add(String key, Object value) { + Map map = new HashMap(); + map.put(key, value); + add(map); + } + + public List getList() { + return list; + } + + public ListObjectOrMapIterator iter() { + return new ListObjectOrMapIterator(); + } + + public interface Key { + public Object getValue(); + public void setValue(Object v); + public void remove(); + } + + class KeyMap implements Key { + protected Map map; + protected Object key; + + public KeyMap(Map map, Object key) { + this.map = map; + this.key = key; + } + + @Override + public Object getValue() { + return map.get(key); + } + + @Override + public void setValue(Object v) { + map.put(key, v); + } + + @Override + public void remove() { + map.remove(key); + } + } + + class KeyList implements Key { + protected List list; + protected int i; + + public KeyList(List list, int i) { + this.list = list; + this.i = i; + } + + @Override + public Object getValue() { + return list.get(i); + } + + @Override + public void setValue(Object v) { + list.set(i, v); + } + + @Override + public void remove() { + list.remove(i); + } + + } + + public class ListObjectOrMapIterator implements Iterator { + protected boolean isMap; + + protected List list; + protected Object[] listEntry; + protected int listIndex; + + protected Map map; + protected Map.Entry[] mapEntry; + protected int mapIndex; + + protected Object next; + protected Key key; + + + public ListObjectOrMapIterator() { + list = ListObjectOrMap.this.list; + listEntry = list.toArray(); + listIndex = 0; + } + + @Override + public boolean hasNext() { + boolean result = false; + if (mapEntry != null && mapIndex < mapEntry.length) { + result = true; + } else { + while (!result && listIndex < listEntry.length) { + next = listEntry[listIndex++]; + isMap = next instanceof Map; + if (isMap) { + map = (Map)next; + Set<Map.Entry> entry = map.entrySet(); + if (!entry.isEmpty()) { + mapEntry = entry.toArray(new Map.Entry[entry.size()]); + mapIndex = 0; + result = true; + } + } else { + result = true; + } + } + } + return result; + } + + @Override + public Object next() { + if (isMap) { + Map.Entry e = mapEntry[mapIndex++]; + key = new KeyMap(map, e.getKey()); + return e.getValue(); + } else { + key = new KeyList(list, listIndex-1); + return next; + } + } + + public Key nextKey() { + next(); + return key; + } + + public Key getKey() { + return key; + } + + public void setValue(Object v) { + key.setValue(v); + } + + @Override + public void remove() { + key.remove(); + } + } + + @Override + public int size() { + return list.size(); + } + + @Override + public boolean isEmpty() { + return list.isEmpty(); + } + + @Override + public boolean contains(Object o) { + return list.contains(o); + } + + @Override + public Iterator iterator() { + return list.iterator(); + } + + @Override + public Object[] toArray() { + return list.toArray(); + } + + @Override + public Object[] toArray(Object[] a) { + return list.toArray(a); + } + + @Override + public boolean add(Object e) { + return list.add(e); + } + + @Override + public boolean remove(Object o) { + return list.remove(o); + } + + @Override + public boolean containsAll(Collection c) { + return list.containsAll(c); + } + + @Override + public boolean addAll(Collection c) { + return list.addAll(c); + } + + @Override + public boolean addAll(int index, Collection c) { + return list.addAll(index, c); + } + + @Override + public boolean removeAll(Collection c) { + return list.removeAll(c); + } + + @Override + public boolean retainAll(Collection c) { + return list.retainAll(c); + } + + @Override + public void clear() { + list.clear(); + } + + @Override + public Object get(int index) { + return list.get(index); + } + + @Override + public Object set(int index, Object element) { + return list.set(index, element); + } + + @Override + public void add(int index, Object element) { + list.add(index, element); + } + + @Override + public Object remove(int index) { + return list.remove(index); + } + + @Override + public int indexOf(Object o) { + return list.indexOf(o); + } + + @Override + public int lastIndexOf(Object o) { + return list.lastIndexOf(o); + } + + @Override + public ListIterator listIterator() { + return list.listIterator(); + } + + @Override + public ListIterator listIterator(int index) { + return list.listIterator(index); + } + + @Override + public List subList(int fromIndex, int toIndex) { + return list.subList(fromIndex, toIndex); + } + +} Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/WikittyQueryMakerAbstract.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/WikittyQueryMakerAbstract.java 2013-02-20 11:31:06 UTC (rev 1530) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/WikittyQueryMakerAbstract.java 2013-02-21 14:28:35 UTC (rev 1531) @@ -264,7 +264,7 @@ } else if (current instanceof FunctionFusion) { current.addArgs(root); } else { - FunctionFusion fusion = new FunctionFusion(root); + FunctionFusion fusion = new FunctionFusion(select.getFunction(), root); select.setFunction(fusion); } } @@ -284,89 +284,164 @@ /////////////////////////////////////////////////////////////////////////// public M fieldValue(String fieldName) { - FunctionFieldValue f = new FunctionFieldValue(null, fieldName); - addFunction(f); - return close(); + return fieldValue(fieldName, null); } public M fieldValue(Element fieldName) { + return fieldValue(fieldName.getValue(), null); + } + + public M fieldValue(Element fieldName, String alias) { return fieldValue(fieldName.getValue()); } + + public M fieldValue(String fieldName, String alias) { + FunctionFieldValue f = new FunctionFieldValue(alias, fieldName); + addFunction(f); + return close(); + } + public M avg() { - FunctionAvg f = new FunctionAvg(null); - return addFunction(f); + return avg((String)null, null); } public M avg(String field) { - FunctionAvg f = new FunctionAvg(null, new FunctionFieldValue(null, field)); - addFunction(f); - return close(); + return avg(field, null); } public M avg(Element field) { - return avg(field.getValue()); + return avg(field.getValue(), null); } + public M avg(Element field, String alias) { + return avg(field.getValue(), alias); + } + + public M avg(String field, String alias) { + if (field == null) { + FunctionAvg f = new FunctionAvg(alias); + addFunction(f); + } else { + FunctionAvg f = new FunctionAvg(alias, new FunctionFieldValue(null, field)); + addFunction(f); + close(); + } + return this.asM(); + } + public M count() { - FunctionCount f = new FunctionCount(null); - return addFunction(f); + return count((String)null, null); } public M count(String field) { - FunctionCount f = new FunctionCount(null, new FunctionFieldValue(null, field)); - addFunction(f); - return close(); + return count(field, null); } public M count(Element field) { - return count(field.getValue()); + return count(field.getValue(), null); } + public M count(Element field, String alias) { + return count(field.getValue(), alias); + } + + public M count(String field, String alias) { + if (field == null) { + FunctionCount f = new FunctionCount(alias); + addFunction(f); + } else { + FunctionCount f = new FunctionCount(alias, new FunctionFieldValue(null, field)); + addFunction(f); + close(); + } + return this.asM(); + } + public M max() { - FunctionMax f = new FunctionMax(null); - return addFunction(f); + return max((String)null, null); } public M max(String field) { - FunctionMax f = new FunctionMax(null, new FunctionFieldValue(null, field)); - addFunction(f); - return close(); + return max(field, null); } public M max(Element field) { - return max(field.getValue()); + return max(field.getValue(), null); } + public M max(Element field, String alias) { + return max(field.getValue(), alias); + } + + public M max(String field, String alias) { + if (field == null) { + FunctionMax f = new FunctionMax(alias); + addFunction(f); + } else { + FunctionMax f = new FunctionMax(alias, new FunctionFieldValue(null, field)); + addFunction(f); + close(); + } + return this.asM(); + } + public M min() { - FunctionMin f = new FunctionMin(null); - return addFunction(f); + return min((String)null, null); } public M min(String field) { - FunctionMin f = new FunctionMin(null, new FunctionFieldValue(null, field)); - addFunction(f); - return close(); + return min(field, null); } public M min(Element field) { - return min(field.getValue()); + return min(field.getValue(), null); } + public M min(Element field, String alias) { + return min(field.getValue(), alias); + } + + public M min(String field, String alias) { + if (field == null) { + FunctionMin f = new FunctionMin(alias); + addFunction(f); + } else { + FunctionMin f = new FunctionMin(alias, new FunctionFieldValue(null, field)); + addFunction(f); + close(); + } + return this.asM(); + + } + public M sum() { - FunctionSum f = new FunctionSum(null); - return addFunction(f); + return sum((String)null, null); } public M sum(String field) { - FunctionSum f = new FunctionSum(null, new FunctionFieldValue(null, field)); - addFunction(f); - return close(); + return sum(field, null); } public M sum(Element field) { - return sum(field.getValue()); + return sum(field.getValue(), null); } + public M sum(Element field, String alias) { + return sum(field.getValue(), alias); + } + + public M sum(String field, String alias) { + if (field == null) { + FunctionSum f = new FunctionSum(alias); + addFunction(f); + } else { + FunctionSum f = new FunctionSum(alias, new FunctionFieldValue(null, field)); + addFunction(f); + close(); + } + return this.asM(); + } + /** * You need to close this distinct * @return @@ -424,7 +499,26 @@ * package.class#method. Il faut ensuite ajouter des arguments a la methode */ public M function(String method, Object ... args) { - WikittyQueryFunctionWrapper f = new WikittyQueryFunctionWrapper(method, null); + return function(method, null, args); + } + + /** + * ajoute une methode definit par l'utilisateur, la syntaxe de methode est + * [package.class]#method. Il faut ensuite ajouter des arguments a la methode + * + * @param method la methode utilisee comme fonction, si l'argument commence + * par #, le nom de la classe courante lui est ajoute. Cela permet de creer + * une sous classe a WikittyQueryMakerAbstract pour son projet et d'y mettre + * l'ensemble des fonctions que l'on utilise dans son projet. + * @param alias l'alias assigne au resultat + * @param args les parametre de la fonction, si vide, il faut alors explicitement + * appeler {@link #close} pour fermer la definition de cette fonction. + */ + public M function(String method, String alias, Object ... args) { + if (StringUtils.startsWith(method, "#")) { + method = this.getClass().getSimpleName() + method; + } + WikittyQueryFunctionWrapper f = new WikittyQueryFunctionWrapper(method, alias); boolean mustClose = false; if (args != null && args.length > 0) { mustClose = true; Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/WikittyQueryVisitorCopy.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/WikittyQueryVisitorCopy.java 2013-02-20 11:31:06 UTC (rev 1530) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/WikittyQueryVisitorCopy.java 2013-02-21 14:28:35 UTC (rev 1531) @@ -25,6 +25,7 @@ package org.nuiton.wikitty.query; import java.util.ArrayList; +import java.util.Deque; import java.util.List; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; @@ -74,9 +75,16 @@ protected WikittyQueryMaker queryMaker; protected List<WikittyQueryFunction> functions = new ArrayList<WikittyQueryFunction>(); - protected List<WikittyQueryFunction> getAndClearFunction() { - List<WikittyQueryFunction> result = functions; - functions = new ArrayList<WikittyQueryFunction>(); + /** + * Prend le nombre d'arg passe en parametre et les supprime de la list + * @param size le nombre de parametre a prendre + * @return + */ + protected List<WikittyQueryFunction> getAndClearFunction(int size) { + int last = functions.size(); + List<WikittyQueryFunction> tmp = functions.subList(last-size, last); + List<WikittyQueryFunction> result = new ArrayList<WikittyQueryFunction>(tmp); + tmp.clear(); return result; } protected void addFunction(WikittyQueryFunction f) { @@ -173,17 +181,18 @@ @Override public boolean visitMiddle(Select o) { - List<WikittyQueryFunction> fs = getAndClearFunction(); - - WikittyQueryFunction f; - if (fs.isEmpty()) { - throw new IllegalStateException("Select must have WikittyQueryFunction"); - } else if (fs.size() > 1) { + WikittyQueryFunction f = null; + if (o.getFunction() != null) { + List<WikittyQueryFunction> fs = getAndClearFunction(1); + // normalement il ne devrait rester qu'une element dans functions et on + // vient de le prendre, si ce n'est pas le cas, c'est un probleme + if (!functions.isEmpty()) { + throw new IllegalStateException("function list must be empty here"); + } f = fs.get(0); - } else { - f = new FunctionFusion(fs); } getQueryMaker().select(f); + getQueryMaker().where(); return true; } @@ -395,7 +404,7 @@ @Override public void visitLeave(WikittyQueryFunction function, boolean enterOrMiddleResult) { - List<WikittyQueryFunction> args = getAndClearFunction(); + List<WikittyQueryFunction> args = getAndClearFunction(function.getArgs().size()); WikittyQueryFunction f = WikittyQueryFunction.create(function.getMethodName(), function.getName(), args); addFunction(f); } Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionAvg.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionAvg.java 2013-02-20 11:31:06 UTC (rev 1530) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionAvg.java 2013-02-21 14:28:35 UTC (rev 1531) @@ -8,6 +8,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.nuiton.wikitty.WikittyUtil; +import org.nuiton.wikitty.query.ListObjectOrMap; import org.nuiton.wikitty.query.WikittyQuery; import org.nuiton.wikitty.services.WikittyTransaction; import org.nuiton.wikitty.storage.WikittySearchEngine; @@ -78,8 +79,9 @@ } BigDecimal avg = total.divide(new BigDecimal(cpt)); - Map<String, Object> val = Collections.singletonMap(getName(), (Object)avg); - List<Map<String, Object>> result = Collections.singletonList(val); + ListObjectOrMap result = new ListObjectOrMap(); + result.add(getName(), avg); + return result; } } Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionCount.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionCount.java 2013-02-20 11:31:06 UTC (rev 1530) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionCount.java 2013-02-21 14:28:35 UTC (rev 1531) @@ -6,6 +6,7 @@ import java.util.Map; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.nuiton.wikitty.query.ListObjectOrMap; import org.nuiton.wikitty.query.WikittyQuery; import org.nuiton.wikitty.services.WikittyTransaction; import org.nuiton.wikitty.storage.WikittySearchEngine; @@ -72,8 +73,9 @@ } } - Map<String, Object> val = Collections.singletonMap(getName(), (Object)cpt); - List<Map<String, Object>> result = Collections.singletonList(val); + ListObjectOrMap result = new ListObjectOrMap(); + result.add(getName(), cpt); + return result; } } Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionFieldValue.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionFieldValue.java 2013-02-20 11:31:06 UTC (rev 1530) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionFieldValue.java 2013-02-21 14:28:35 UTC (rev 1531) @@ -10,6 +10,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.nuiton.wikitty.entities.Element; +import org.nuiton.wikitty.query.ListObjectOrMap; import org.nuiton.wikitty.query.WikittyQuery; import org.nuiton.wikitty.services.WikittyTransaction; import org.nuiton.wikitty.storage.WikittySearchEngine; @@ -57,16 +58,17 @@ String field = getUniqueValue(fieldName).toString(); - List<Map<String, Object>> result = new ArrayList<Map<String, Object>>(data.size()); + ListObjectOrMap result = new ListObjectOrMap(); + for (Map<String, Object> m : data) { if (m.containsKey(field)) { Object val = m.get(field); if (val instanceof Collection) { for (Object o : (Collection)val) { - result.add(Collections.singletonMap(field, o)); + result.add(field, o); } } else { - result.add(Collections.singletonMap(field, val)); + result.add(field, val); } } } Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionFusion.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionFusion.java 2013-02-20 11:31:06 UTC (rev 1530) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionFusion.java 2013-02-21 14:28:35 UTC (rev 1531) @@ -7,6 +7,7 @@ import java.util.Map; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.nuiton.wikitty.WikittyException; import org.nuiton.wikitty.query.WikittyQuery; import org.nuiton.wikitty.services.WikittyTransaction; import org.nuiton.wikitty.storage.WikittySearchEngine; @@ -41,13 +42,18 @@ WikittySearchEngine searchEngine, WikittyTransaction tx, WikittyQuery query, List<Map<String, Object>> data) { - List<List<Map<String, Object>>> all = new ArrayList<List<Map<String, Object>>>(); - for (WikittyQueryFunction f : getArgs()) { - all.add(f.call(searchEngine, tx, query, data)); + try { + List<List<Map<String, Object>>> all = new ArrayList<List<Map<String, Object>>>(); + for (WikittyQueryFunction f : getArgs()) { + all.add(f.call(searchEngine, tx, query, data)); + } + + List<Map<String, Object>> result = fusion(all); + return result; + } catch (Exception eee) { + throw new WikittyException(String.format( + "Can't evaluate function %s", this), eee); } - - List<Map<String, Object>> result = fusion(all); - return result; } } Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionMax.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionMax.java 2013-02-20 11:31:06 UTC (rev 1530) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionMax.java 2013-02-21 14:28:35 UTC (rev 1531) @@ -6,6 +6,7 @@ import java.util.Map; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.nuiton.wikitty.query.ListObjectOrMap; import org.nuiton.wikitty.query.WikittyQuery; import org.nuiton.wikitty.services.WikittyTransaction; import org.nuiton.wikitty.storage.WikittySearchEngine; @@ -71,8 +72,8 @@ } } - List<Map<String, Object>> result = Collections.singletonList( - Collections.singletonMap(getName(), (Object)candidate)); + ListObjectOrMap result = new ListObjectOrMap(); + result.add(getName(), candidate); return result; } } Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionMin.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionMin.java 2013-02-20 11:31:06 UTC (rev 1530) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionMin.java 2013-02-21 14:28:35 UTC (rev 1531) @@ -6,6 +6,7 @@ import java.util.Map; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.nuiton.wikitty.query.ListObjectOrMap; import org.nuiton.wikitty.query.WikittyQuery; import org.nuiton.wikitty.services.WikittyTransaction; import org.nuiton.wikitty.storage.WikittySearchEngine; @@ -71,8 +72,8 @@ } } - List<Map<String, Object>> result = Collections.singletonList( - Collections.singletonMap(getName(), (Object)candidate)); + ListObjectOrMap result = new ListObjectOrMap(); + result.add(getName(), candidate); return result; } } Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionSum.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionSum.java 2013-02-20 11:31:06 UTC (rev 1530) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionSum.java 2013-02-21 14:28:35 UTC (rev 1531) @@ -8,6 +8,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.nuiton.wikitty.WikittyUtil; +import org.nuiton.wikitty.query.ListObjectOrMap; import org.nuiton.wikitty.query.WikittyQuery; import org.nuiton.wikitty.services.WikittyTransaction; import org.nuiton.wikitty.storage.WikittySearchEngine; @@ -73,8 +74,9 @@ } } } - Map<String, Object> val = Collections.singletonMap(getName(), (Object)total); - List<Map<String, Object>> result = Collections.singletonList(val); + + ListObjectOrMap result = new ListObjectOrMap(); + result.add(getName(), total); return result; } } Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionValue.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionValue.java 2013-02-20 11:31:06 UTC (rev 1530) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/FunctionValue.java 2013-02-21 14:28:35 UTC (rev 1531) @@ -7,6 +7,7 @@ import org.apache.commons.lang3.ObjectUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.nuiton.wikitty.query.ListObjectOrMap; import org.nuiton.wikitty.query.WikittyQuery; import org.nuiton.wikitty.query.WikittyQueryVisitor; import org.nuiton.wikitty.services.WikittyTransaction; @@ -46,8 +47,8 @@ public List<Map<String, Object>> call( WikittySearchEngine searchEngine, WikittyTransaction tx, WikittyQuery query, List<Map<String, Object>> data) { - List<Map<String, Object>> result = - Collections.singletonList(Collections.singletonMap(getName(), value)); + ListObjectOrMap result = new ListObjectOrMap(); + result.add(getName(), getValue()); return result; } Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/WikittyQueryFunction.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/WikittyQueryFunction.java 2013-02-20 11:31:06 UTC (rev 1530) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/WikittyQueryFunction.java 2013-02-21 14:28:35 UTC (rev 1531) @@ -15,6 +15,7 @@ import org.nuiton.wikitty.WikittyUtil; import org.nuiton.wikitty.query.WikittyQuery; import org.nuiton.wikitty.query.WikittyQueryVisitor; +import org.nuiton.wikitty.query.WikittyQueryVisitorToString; import org.nuiton.wikitty.services.WikittyTransaction; import org.nuiton.wikitty.storage.WikittySearchEngine; @@ -186,6 +187,16 @@ WikittySearchEngine searchEngine, WikittyTransaction tx, WikittyQuery query, List<Map<String, Object>> data); + @Override + public String toString() { + WikittyQueryVisitorToString v = new WikittyQueryVisitorToString(); + accept(v); + String result = v.getText(); + return result; + } + + + protected List<Map<String, Object>> fusion(List<List<Map<String, Object>>> listData) { List<Map<String, Object>> result = new ArrayList<Map<String, Object>>(); // check size, all list must have same size @@ -195,7 +206,9 @@ size = e.size(); } else { if (size != e.size()) { - throw new IllegalArgumentException("Each list must have same size"); + throw new IllegalArgumentException(String.format( + "Each list must have same size %s != %s (%s)", + size, e.size(), listData)); } } } @@ -262,14 +275,17 @@ * @return */ protected Method getMethod(String fqMethod) { - List<Method> methods = ObjectUtil.getMethod(name, true); + List<Method> methods = ObjectUtil.getMethod(fqMethod, true); - Method result = null; - if (methods.size() > 0) { + Method result; + if (methods.isEmpty()) { + throw new IllegalArgumentException(String.format( + "Can't find method '%s'", fqMethod)); + } else { if (methods.size() > 1) { log.warn(String.format( - "More than one method found, used the first: %s", - methods)); + "More than one method found for '%s', used the first: %s", + fqMethod, methods)); } result = methods.get(0); } Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/WikittyQueryFunctionWrapper.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/WikittyQueryFunctionWrapper.java 2013-02-20 11:31:06 UTC (rev 1530) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/query/function/WikittyQueryFunctionWrapper.java 2013-02-21 14:28:35 UTC (rev 1531) @@ -1,15 +1,18 @@ package org.nuiton.wikitty.query.function; - import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.util.ArrayList; import java.util.Arrays; +import java.util.Date; +import java.util.HashMap; +import java.util.Iterator; import java.util.List; import java.util.Map; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.nuiton.util.ObjectUtil; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyUtil; import org.nuiton.wikitty.query.WikittyQuery; import org.nuiton.wikitty.services.WikittyTransaction; import org.nuiton.wikitty.storage.WikittySearchEngine; @@ -41,13 +44,13 @@ WikittySearchEngine searchEngine, WikittyTransaction tx, WikittyQuery query, List<Map<String, Object>> data) { List<List<Map<String, Object>>> param = new ArrayList<List<Map<String, Object>>>(); - + + // on evalue les parametres que l'on passera a la fonction for (WikittyQueryFunction f : getArgs()) { param.add(f.call(searchEngine, tx, query, data)); } - data = fusion(param); - + // on recherche la fonction et on instancie si besoin un objet pour l'executer Method method = getMethod(methodName); Object target = null; if (!Modifier.isStatic(method.getModifiers())) { @@ -61,22 +64,134 @@ } } - for (Map<String, Object> o : data) { - String[] args = new String[o.size()]; - int i=0; - for (Object v : o.values()) { - args[i++] = String.valueOf(v); + // on initialise tous les iterateurs qui fourniront les parametres + List<Iterator<Map<String, Object>>> paramIterator = new ArrayList<Iterator<Map<String, Object>>>(); + for(List<Map<String, Object>> l : param) { + paramIterator.add(l.iterator()); + } + + List<Map<String, Object>> resultListMap = new ArrayList<Map<String, Object>>(); + List<Map<String, Object>> p = null; + while (hasNext(paramIterator)) { + // on recupere dans p les parametre a utiliser pour le prochain appel + p = next(paramIterator, p); + // on appelle la fonction + Object result = invoke(target, method, p); + // si le retour n'est pas une map, on le transforme en map + if (!(result instanceof Map)) { + result = WikittyUtil.singletonMap(getName(), result); } - try { - Object r = ObjectUtil.call(target, method, args); - } catch (Exception eee) { - throw new IllegalStateException(String.format( - "Can't call function '%s'", - methodName), eee); + resultListMap.add((Map)result); + } + + return resultListMap; + } + + /** + * Il y a un suivant tant qu'un des iterators a un suivant + * + * @param paramIterator + * @return + */ + protected boolean hasNext(List<Iterator<Map<String, Object>>> paramIterator) { + boolean result = false; + for (Iterator i : paramIterator) { + result = result || i.hasNext(); + } + return result; + } + + /** + * Retourne le suivant de chaque iterator, si un iterator n'a plus de suivant, + * on reutilise l'ancien resultat + * @param paramIterator + * @return + */ + protected List<Map<String, Object>> next(List<Iterator<Map<String, Object>>> paramIterator, + List<Map<String, Object>> last) { + List<Map<String, Object>> result = new ArrayList<Map<String, Object>>(); + + int cpt=0; + for (Iterator<Map<String, Object>> i : paramIterator) { + if(i.hasNext()) { + result.add(i.next()); + } else { + if (last != null) { + result.add(last.get(cpt)); + } else { + result.add(null); + } } + cpt++; } - return data; + + return result; } + /** + * + * @param target l'objet sur lequel appeler la methode + * @param method la methode a appeler + * @param p les arguments a convertir le mieux possible pour pouvoir appeler la methode + * @return + */ + protected Object invoke(Object target, Method method, List<Map<String, Object>> p) { + Class[] pClass = method.getParameterTypes(); + Object[] param = new Object[pClass.length]; + int cpt = 0; + for (Class c : pClass) { + Object value; + if (Map.class.isAssignableFrom(c)) { + value = p.get(cpt); + } else if (Number.class.isAssignableFrom(c) + || Byte.TYPE.isAssignableFrom(c) + || Short.TYPE.isAssignableFrom(c) + || Integer.TYPE.isAssignableFrom(c) + || Long.TYPE.isAssignableFrom(c) + || Float.TYPE.isAssignableFrom(c) + || Double.TYPE.isAssignableFrom(c)) { + value = WikittyUtil.toNumber(c, WikittyUtil.toBigDecimal(takeValue(p.get(cpt)))); + } else if (Date.class.isAssignableFrom(c)) { + value = WikittyUtil.toDate(takeValue(p.get(cpt))); + } else if (Boolean.TYPE.isAssignableFrom(c) || Boolean.class.isAssignableFrom(c)) { + value = WikittyUtil.toBoolean(takeValue(p.get(cpt))); + } else if (byte[].class.isAssignableFrom(c)) { + value = WikittyUtil.toBinary(takeValue(p.get(cpt))); + } else if (String.class.isAssignableFrom(c)) { + value = WikittyUtil.toString(takeValue(p.get(cpt))); + }else { + throw new ClassCastException(String.format( + "Object '%s' is not convertible to '%s'" + + " (accepted Number, String, Date," + + " Boolean, byte[], Map)", + p.get(cpt), c.getName())); + } + param[cpt] = value; + cpt++; + } + + try { + Object result = method.invoke(target, param); + return result; + } catch (Exception eee) { + throw new WikittyException(String.format( + "Can't execute function (method: '%s' args:'%s')", + method, Arrays.toString(param)), eee); + } + } + + /** + * Prend la valeur de la map, la map ne doit contenir qu'une valeur + * @param map + * @return null si la map est vide + */ + protected Object takeValue(Map<String, Object> map) { + if (map != null) { + for(Object v : map.values()) { + return v; + } + } + return null; + } } Deleted: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/storage/WikittySearchEngineHelper.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/storage/WikittySearchEngineHelper.java 2013-02-20 11:31:06 UTC (rev 1530) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/storage/WikittySearchEngineHelper.java 2013-02-21 14:28:35 UTC (rev 1531) @@ -1,239 +0,0 @@ -/* - * #%L - * Wikitty :: api - * - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2012 CodeLutin, Benjamin Poussin - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Lesser Public License for more details. - * - * You should have received a copy of the GNU General Lesser Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/lgpl-3.0.html>. - * #L% - */ -package org.nuiton.wikitty.storage; - -import java.io.Serializable; -import java.math.BigDecimal; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.Map; -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.Element; -import org.nuiton.wikitty.entities.WikittyExtension; -import org.nuiton.wikitty.query.function.WikittyQueryFunction; -import org.nuiton.wikitty.query.FacetSortType; -import org.nuiton.wikitty.query.FacetTopic; -import org.nuiton.wikitty.query.WikittyQuery; -import org.nuiton.wikitty.query.WikittyQueryMaker; -import org.nuiton.wikitty.query.WikittyQueryResult; -import org.nuiton.wikitty.query.conditions.Condition; -import org.nuiton.wikitty.query.conditions.Select; -import org.nuiton.wikitty.services.WikittyTransaction; - -/** - * Ensemble de methode reutilisable dans differente implantation de - * {@link WikittySearchEngine} - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public class WikittySearchEngineHelper { - - /** to use log facility, just put in your code: log.info(\"...\"); */ - static private Log log = LogFactory.getLog(WikittySearchEngineHelper.class); - -// /** -// * Gere le travail pour les requetes ayant un {@link Select} -// * -// * @param searchEngine le searchEngine a utiliser pour les sous requetes -// * @param transaction la transaction a utiliser -// * @param query la requete qui debute par un {@link Select} -// * @return -// */ -// static public WikittyQueryResult<String> findAllByQueryWithSelectOLD( -// WikittySearchEngine searchEngine, WikittyTransaction transaction, -// WikittyQuery query) { -// -// if (!(query.getCondition() instanceof Select)) { -// throw new WikittyException("Query don't start with Select condition"); -// } else { -// // gere les conditions qui commence par select -// // il faut recreer deux query, une pour le select, une pour les facettes s'il y en a -// // car le select est execute via une facette, mais cette facette -// // n'a pas les meme limites que les autres facette -// -// Select select = (Select)query.getCondition(); -// boolean isAggregate = select.getAggregate() != null; -// boolean isDistinct = select.isDistinct(); -// -// Condition newCond; -// if(WikittyExtension.isFqField(select.getElement().getValue())) { -// String extName = WikittyExtension.extractExtensionName( -// select.getElement().getValue()); -// newCond = new WikittyQueryMaker() -// .and() -// .exteq(extName) -// .condition(select.getSubCondition()) -// .getCondition(); -// } else { -// newCond = select.getSubCondition(); -// } -// -// // copy de la query pour les facettes -// WikittyQuery queryFacet = query.copy(); -// queryFacet.setCondition(newCond); -// queryFacet.setLimit(0); -// -// // copy de la query pour le select -// // on part de facet qui a deja la bonne condition -// WikittyQuery querySelect = queryFacet.copy(); -// querySelect.setLimit(0); -// // ne surtout pas mettre 0, sinon toutes les valeurs possibles sont -// // retournee pas seulement celle qui satisfont la contrainte -// querySelect.setFacetMinCount(1); -// querySelect.setFacetLimit(Integer.MAX_VALUE); -// // on force le sort pour toujours utiliser le meme -// querySelect.setFacetSort(FacetSortType.name); -// // on supprime toutes les facettes, et on ajoute la notre -// querySelect.setFacetQuery(); -// querySelect.setFacetField(select.getElement()); -// -// // execution des requetes -// WikittyQueryResult<String> resultFacet = -// searchEngine.findAllByQuery(transaction, queryFacet); -// WikittyQueryResult<String> resultSelect = -// searchEngine.findAllByQuery(transaction, querySelect); -// -// // creation des resultats via la facette select -// List<FacetTopic> topics = resultSelect.getFacets().get(select.getElement().getValue()); -// -// List<String> selectList = new ArrayList<String>(topics.size()); -// for (FacetTopic topic : topics) { -// if (isDistinct) { -// selectList.add(topic.getTopicName()); -// } else { -// // on ajoute la valeur le nombre de fois qu'il y a de count dans la facette -// for (int i=0, max=topic.getCount(); i<max; i++) { -// selectList.add(topic.getTopicName()); -// } -// } -// } -// -// boolean sortDesc = query.getSortDescending().contains(select.getElement()); -// // tri selon l'ordre demande -// if (sortDesc) { -// // par defaut la facette est deja trie par ordre alphabetique -// // donc il n'y a qu'a l'inverser pour avoir l'ordre inverse -// Collections.reverse(selectList); -// } -// -// // on ne garde que ce qui est demande -// int offset = query.getOffset(); -// int limit = query.getLimit(); -// if (limit == Integer.MAX_VALUE) { -// // WARNING It is necessary to substract 'offset' otherwise, -// // there is a capacity overlow -// limit = Integer.MAX_VALUE - offset; -// } -// int first = Math.min(selectList.size(), offset); -// int last = Math.min(selectList.size(), offset + limit); -// selectList = selectList.subList(first, last); -// -// -// -// // gestion des agregats -// if (isAggregate) { -// switch(select.getAggregate()) { -// case AVG: { -// // convert all to number -// BigDecimal result = new BigDecimal(0); -// for (String s : selectList) { -// BigDecimal v = WikittyUtil.toBigDecimal(s); -// result = result.add(v); -// } -// result = result.divide(new BigDecimal(selectList.size())); -// selectList = new ArrayList<String>(); -// selectList.add(WikittyUtil.toString(result)); -// } -// break; -// case COUNT: { -// // convert all to number -// BigDecimal result = new BigDecimal(selectList.size()); -// selectList = new ArrayList<String>(); -// selectList.add(WikittyUtil.toString(result)); -// } -// break; -// case MAX: { -// if (!selectList.isEmpty()) { -// String result; -// if (sortDesc) { -// result = selectList.get(0); -// } else { -// result = selectList.get(selectList.size()-1); -// } -// selectList = new ArrayList<String>(); -// selectList.add(WikittyUtil.toString(result)); -// } -// } -// break; -// case MIN: { -// if (!selectList.isEmpty()) { -// String result; -// if (sortDesc) { -// result = selectList.get(selectList.size()-1); -// } else { -// result = selectList.get(0); -// } -// selectList = new ArrayList<String>(); -// selectList.add(WikittyUtil.toString(result)); -// } -// } -// break; -// case SUM: { -// // convert all to number -// BigDecimal result = new BigDecimal(0); -// for (String s : selectList) { -// BigDecimal v = WikittyUtil.toBigDecimal(s); -// result = result.add(v); -// } -// selectList = new ArrayList<String>(); -// selectList.add(WikittyUtil.toString(result)); -// } -// break; -// } -// } -// -// // fusion des resultats -// WikittyQueryResult<String> result = new WikittyQueryResult<String>( -// query.getName(), -// query.getOffset(), -// topics.size(), -// resultSelect.getQueryString(), -// resultFacet.getFacets(), -// selectList, -// 0, 0); -// -// return result; -// } -// } - -} Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/storage/WikittySearchEngineInMemory.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/storage/WikittySearchEngineInMemory.java 2013-02-20 11:31:06 UTC (rev 1530) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/storage/WikittySearchEngineInMemory.java 2013-02-21 14:28:35 UTC (rev 1531) @@ -26,7 +26,6 @@ import com.google.common.collect.Multiset; import com.google.common.collect.TreeMultiset; -import java.io.Serializable; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; @@ -374,7 +373,7 @@ if (select == null) { String idTag = org.nuiton.wikitty.entities.Element.ID.getValue(); for (Object id : ids) { - values.add(Collections.singletonMap(idTag, id)); + values.add(WikittyUtil.singletonMap(idTag, id)); } } else { // Extract data 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 2013-02-20 11:31:06 UTC (rev 1530) +++ trunk/wikitty-solr/src/main/java/org/nuiton/wikitty/storage/solr/WikittySearchEngineSolr.java 2013-02-21 14:28:35 UTC (rev 1531) @@ -26,10 +26,8 @@ package org.nuiton.wikitty.storage.solr; import java.io.File; -import java.io.Serializable; import java.util.ArrayList; import java.util.Collection; -import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; @@ -76,7 +74,6 @@ import org.nuiton.wikitty.services.WikittyTransaction; import org.nuiton.wikitty.storage.WikittyExtensionStorage; import org.nuiton.wikitty.storage.WikittySearchEngine; -import org.nuiton.wikitty.storage.WikittySearchEngineHelper; /** * @@ -813,7 +810,7 @@ String idTag = org.nuiton.wikitty.entities.Element.ID.getValue(); for (SolrDocument doc : solrResults) { Object id = SolrUtil.getStringFieldValue(doc, SOLR_ID); - values.add(Collections.singletonMap(idTag, id)); + values.add(WikittyUtil.singletonMap(idTag, id)); } } else { // Extract data @@ -838,158 +835,6 @@ } } - // TODO Remove it -// @Override -// public WikittyQueryResult<String> findAllByQueryOLD(WikittyTransaction transaction, WikittyQuery query) { -// try { -// WikittyQueryResult<String> result; -// -// if (query.getCondition() instanceof Select) { -// result = WikittySearchEngineHelper.findAllByQueryWithSelect( -// this, transaction, query); -// } else { -// -// // Create querySolr -// WikittyQueryVisitorToSolr v = new WikittyQueryVisitorToSolr( -// transaction, this, elementModifier, query.getWikittyFieldSearchDepth()); -// query.getCondition().accept(v); -// String queryString = v.getSolrQuery(); -// SolrQuery querySolr = new SolrQuery(SOLR_QUERY_PARSER + queryString); -// -// // Add paged -// int offset = query.getOffset(); -// int limit = query.getLimit(); -// -// if (limit == Integer.MAX_VALUE) { -// // WARNING It is necessary to substract 'start' otherwise, -// // there is a capacity overlow in solR -// limit = Integer.MAX_VALUE - offset; -// } -// querySolr.setStart(offset); -// querySolr.setRows(limit); -// -// // Add sorting -// List<Element> sortAscending = query.getSortAscending(); -// if(sortAscending != null) { -// for (Element sort : sortAscending) { -// String tranform = elementModifier.convertToSolr(transaction, sort); -// tranform += WikittySolrConstant.SUFFIX_SORTABLE; -// querySolr.addSortField(tranform, SolrQuery.ORDER.asc); -// } -// } -// -// List<Element> sortDescending = query.getSortDescending(); -// if(sortDescending != null) { -// for (Element sort : sortDescending) { -// String tranform = elementModifier.convertToSolr(transaction, sort); -// tranform += WikittySolrConstant.SUFFIX_SORTABLE; -// querySolr.addSortField(tranform, SolrQuery.ORDER.desc); -// } -// } -// -// // Add faceting -// boolean isFacetExtension = query.isFacetExtension(); -// List<Element> facetField = query.getFacetField(); -// List<FacetQuery> facetQuery = query.getFacetQuery(); -// -// // use to map query string to criteria facet name -// Map<String, String> facetQueryToName = new HashMap<String, String>(); -// -// if (isFacetExtension -// || CollectionUtils.isNotEmpty(facetField) -// || CollectionUtils.isNotEmpty(facetQuery)) { -// querySolr.setFacet(true); -// querySolr.setFacetMinCount(query.getFacetMinCount()); -// querySolr.setFacetLimit(query.getFacetLimit()); -// querySolr.setFacetSort(query.getFacetSort().solrValue); -// -// if (isFacetExtension) { -// querySolr.addFacetField(WikittySolrConstant.SOLR_EXTENSIONS); -// } -// -// // field facetisation -// if (facetField != null) { -// for (Element fqfieldName : facetField) { -// String tranform = elementModifier.convertToSolr(transaction, fqfieldName); -// querySolr.addFacetField(tranform); -// } -// } -// -// // query facetisation -// if (facetQuery != null) { -// for (FacetQuery facet : facetQuery) { -// v = new WikittyQueryVisitorToSolr( -// transaction, this, elementModifier, 0); // pas de recherche recursive sur les champs wikitty pour les facettes -// facet.getCondition().accept(v); -// String queryFacet = v.getSolrQuery(); -// facetQueryToName.put(queryFacet, facet.getName()); -// querySolr.addFacetQuery(queryFacet); -// } -// } -// } -// -// QueryResponse resp = SolrUtil.executeQuery(solrServer, querySolr); -// SolrDocumentList solrResults = resp.getResults(); -// -// Map<String, List<FacetTopic>> facets = new HashMap<String, List<FacetTopic>>(); -// -// // la facet sur les extensions est directement et convenablement -// // gere comme un champs -// if (isFacetExtension || CollectionUtils.isNotEmpty(facetField)) { -// for (FacetField facet : resp.getFacetFields()) { -// String facetName = elementModifier.convertToField(facet.getName()); -// List<FacetTopic> topics = new ArrayList<FacetTopic>(); -// if (facet.getValues() != null) { -// for (FacetField.Count value : facet.getValues()) { -// String topicName = value.getName(); -// int topicCount = (int) value.getCount(); -// FacetTopic topic = new FacetTopic(facetName, topicName, topicCount); -// topics.add(topic); -// } -// } -// facets.put(facetName, topics); -// } -// } -// -// if (CollectionUtils.isNotEmpty(facetQuery)) { -// for (Map.Entry<String, Integer> facet : resp.getFacetQuery().entrySet()) { -// String facetName = facet.getKey(); -// // don't use contains because, map can have key with null value -// if (null != facetQueryToName.get(facetName)) { -// facetName = facetQueryToName.get(facetName); -// } -// Integer count = facet.getValue(); -// List<FacetTopic> topics = new ArrayList<FacetTopic>(); -// FacetTopic topic = new FacetTopic(facetName, facetName, count); -// topics.add(topic); -// facets.put(facetName, topics); -// } -// } -// -// // Extract ids -// List<String> ids = new ArrayList<String>(solrResults.size()); -// for (SolrDocument doc : solrResults) { -// -// String id = SolrUtil.getStringFieldValue(doc, SOLR_ID); -// ids.add(id); -// } -// -// // Get total num found -// int numFound = (int)resp.getResults().getNumFound(); -// -// // Build paged result -// result = new WikittyQueryResult<String>( -// query.getName(), -// offset, numFound, queryString, facets, ids, 0, 0); -// -// } -// return result; -// } catch (SolrServerException eee) { -// throw new WikittyException(String.format( -// "Error during find of query '%s'", query), eee); -// } -// } - /** * Si l'argument n'est pas un TreeNode, une exception est levee *