Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * #%L
    * Wikitty :: api
    * %%
    * 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.query;
  
  import java.util.Arrays;
  import java.util.Deque;
  import java.util.List;
Cette objet sert a construire une condition a la facon d'un flux.

Condition c = new WikittyQueryMaker().and().eq("ext.field", "toto").eq("ext.field2", 10).getCondition();

On peut aussi vouloir continuer avec un WikittyQuery pour cela on peut faire.

WikittyQuery q = new WikittyQueryMaker().and().[other condition].end();

Si un WikittyQuery est passé en parametre du constructeur et que la method end() est appeler alors la condition creee est envoyee dans le WikittyQuery et le constructeur est fermer (on ne peut plus ajouter de condition)

Le WikittyQuery lie avec cet objet lorsqu'on le recupere via la method getQuery() a en interne comme condition la valuer courante de la condition en cours d'ecriture Cette classe est abstraite pour facilite l'heritage pour une utilisation dans des applications qui auraient besoin d'ajouter des methodes de construction (par exemple des methodes qui ajouteraient un ensemble de contraintes). Pour cela il faut heriter de cette classe et implanter la methode asM() Par exemple:

 class MonMaker extends WikittyQueryMakerAbstract<MonMaker> {

     // ... constructeurs et methodes supplementaires ...

     

Author(s):
poussin
Version:
$Revision$
Since:
3.3 Last update: $Date$ by : $Author$
Override:
MonMaker asM() { return this; } }
 
 public abstract class WikittyQueryMakerAbstract<M extends WikittyQueryMakerAbstract> {

    
to use log facility, just put in your code: log.info(\"...\");
 
     static private Log log = LogFactory.getLog(WikittyQueryMakerAbstract.class);

    
query where to send condition when end() method called
 
     protected WikittyQuery query;

    
query condition
 
     protected Condition condition;
    
stack des conditions non terminales ouvertes
 
     protected Deque<ConditionopenStack = new LinkedList<Condition>();
    
stack des function ouvertes
 
 
     public WikittyQueryMakerAbstract() {
     }
 
     public WikittyQueryMakerAbstract(WikittyQuery query) {
         this. = query;
     }
 
     protected abstract M asM();
 
     public Condition getCondition() {
         return ;
     }

    
La query passee dans le constructeur ou une nouvelle query si aucune query n'avait ete passee dans le constructeur

Returns:
 
     public WikittyQuery getQuery() {
         if ( == null) {
              = new WikittyQuery();
         }
         // la condition de la query doit toujours refleter la valeur courante
         // de la condition en cours de creation
         .setCondition(getCondition());
         return ;
     }

    
Retourne le stack courant des conditions, si le stack est null cela veut dire que le maker ne permet plus de modification

Returns:
 
     protected Deque<ConditiongetOpenStack() {
         if ( == null) {
             throw new WikittyException(
                     "You can't create condition if you have used setCondition method"
                     + " or close last condition");
         }
         return ;
     }

    
Ajout une condition
 
     protected void addCondition(Condition c) {
         addCondition(cfalse);
     }
    
Ajout une condition. Si terminal est true, alors quelque soit le type de cette condition la stack restera inchange apres l'ajout. Cela permet d'ajouter des conditions non terminale comme des terminales
 
     protected void addCondition(Condition cboolean terminal) {
         Condition parent = getOpenStack().peek();
         if (!terminal) {
             // on ne met les conditions toujours dans le stack (meme les terminales)
             // si c'est la premiere cela permet d'indiquer a l'utilisateur
             // qu'il faut commencer par un or, and, not car une exception sera
             // levee car non supprimer par le while dans lequel on ne passe pas
             // car on passe dans le if et non le else (parent == null)
             getOpenStack().push(c);
         }
 
         if (parent == null) {
             // il n'y a rien dans la stack donc rien dans condition, il faut
             // mettre cette condition dedans
              = c;
             // et on ne depile pas le stack
         } else {
             // se add peut lever une exception si parent n'accepte pas cet enfant
             parent.addCondition(c);
             // on depile toutes les conditions qui n'ont plus besoin de renseignement
             // sauf si l'ajout a ete force en terminal
             if (!terminal) {
                 closeIfNecessary();
             }
         }
     }
 
     protected void closeIfNecessary() {
         // on depile toutes les conditions qui n'ont plus besoin de renseignement
         while (getOpenStack().peek() != null
                 && !getOpenStack().peek().waitCondition()) {
             getOpenStack().poll();
         }
         if (getOpenStack().size() == 0) {
             // we just close last open condition, set stack to null, to prevent
             // next condition add that is mistake
              = null;
         }
     }
 
         Condition c = getOpenStack().peek();
         if (c instanceof Select) {
             return ;
         } else {
             throw new IllegalStateException("You can use function only in Select clause");
         }
     }
 
     public M addFunction(WikittyQueryFunction f) {
         WikittyQueryFunction parent = getOpenStackFunction().peek();
         getOpenStackFunction().push(f);
 
         if (parent != null) {
             parent.addArgs(f);
         }
         return this.asM();
     }

    
Assigne les functions au Select et prepare l'ecriture de la condition

Returns:
 
     public M where() {
         Condition c = getOpenStack().peek();
         if (c != null) { // pas de condition on ne fait rien
             if (c instanceof Select) {
                 // un select on lui assigne la premiere function
                 WikittyQueryFunction root = getOpenStackFunction().peekLast();
                 if (root != null) {
                     Select select = (Select)c;
                     WikittyQueryFunction current = select.getFunction();
                     if (current == null) {
                         select.setFunction(root);
                     } else if (current instanceof FunctionFusion) {
                         current.addArgs(root);
                     } else {
                         FunctionFusion fusion = new FunctionFusion(select.getFunction(), root);
                         select.setFunction(fusion);
                     }
                 }
                 // et on vide la stack de function
                 getOpenStackFunction().clear();
             } else {
                 throw new IllegalStateException("You can use Where only after select or at beginning of condition");
             }
         }
         return this.asM();
     }
 
     ///////////////////////////////////////////////////////////////////////////
     //
     // F U N C T I O N   F L O W   C R E A T I O N
     //
     ///////////////////////////////////////////////////////////////////////////
 
     public M fieldValue(String fieldName) {
         return fieldValue(fieldNamenull);
     }
 
     public M fieldValue(Element fieldName) {
         return fieldValue(fieldName.getValue(), null);
     }
 
     public M fieldValue(Element fieldNameString alias) {
         return fieldValue(fieldName.getValue());
     }
 
     public M fieldValue(String fieldNameString alias) {
         FunctionFieldValue f = new FunctionFieldValue(aliasfieldName);
         addFunction(f);
         return close();
     }
 
     public M avg() {
         return avg((String)nullnull);
     }
 
     public M avg(String field) {
         return avg(fieldnull);
     }
 
     public M avg(Element field) {
         return avg(field.getValue(), null);
     }
 
     public M avg(Element fieldString alias) {
         return avg(field.getValue(), alias);
     }
 
     public M avg(String fieldString alias) {
         if (field == null) {
             FunctionAvg f = new FunctionAvg(alias);
             addFunction(f);
         } else {
             FunctionAvg f = new FunctionAvg(aliasnew FunctionFieldValue(nullfield));
             addFunction(f);
             close();
         }
         return this.asM();
     }
 
     public M count() {
         return count((String)nullnull);
     }
 
     public M count(String field) {
         return count(fieldnull);
     }
 
     public M count(Element field) {
         return count(field.getValue(), null);
     }
 
     public M count(Element fieldString alias) {
         return count(field.getValue(), alias);
     }
 
     public M count(String fieldString alias) {
         if (field == null) {
             FunctionCount f = new FunctionCount(alias);
             addFunction(f);
         } else {
             FunctionCount f = new FunctionCount(aliasnew FunctionFieldValue(nullfield));
             addFunction(f);
             close();
         }
         return this.asM();
     }
 
     public M max() {
         return max((String)nullnull);
     }
 
     public M max(String field) {
         return max(fieldnull);
     }
 
     public M max(Element field) {
         return max(field.getValue(), null);
     }
 
     public M max(Element fieldString alias) {
         return max(field.getValue(), alias);
     }
 
     public M max(String fieldString alias) {
         if (field == null) {
             FunctionMax f = new FunctionMax(alias);
             addFunction(f);
         } else {
             FunctionMax f = new FunctionMax(aliasnew FunctionFieldValue(nullfield));
             addFunction(f);
             close();
         }
         return this.asM();
     }
 
     public M min() {
         return min((String)nullnull);
     }
 
     public M min(String field) {
         return min(fieldnull);
     }
 
     public M min(Element field) {
         return min(field.getValue(), null);
     }
 
     public M min(Element fieldString alias) {
         return min(field.getValue(), alias);
     }
 
     public M min(String fieldString alias) {
         if (field == null) {
             FunctionMin f = new FunctionMin(alias);
             addFunction(f);
         } else {
             FunctionMin f = new FunctionMin(aliasnew FunctionFieldValue(nullfield));
             addFunction(f);
             close();
         }
         return this.asM();
 
     }
 
     public M sum() {
         return sum((String)nullnull);
     }
 
     public M sum(String field) {
         return sum(fieldnull);
     }
 
     public M sum(Element field) {
         return sum(field.getValue(), null);
     }
 
     public M sum(Element fieldString alias) {
         return sum(field.getValue(), alias);
     }
 
     public M sum(String fieldString alias) {
         if (field == null) {
             FunctionSum f = new FunctionSum(alias);
             addFunction(f);
         } else {
             FunctionSum f = new FunctionSum(aliasnew FunctionFieldValue(nullfield));
             addFunction(f);
             close();
         }
         return this.asM();
     }

    
You need to close this distinct

Returns:
 
     public M distinct() {
         FunctionDistinct f = new FunctionDistinct();
         return addFunction(f);
     }

    
if field is passed in argument then this this distinct is auto closed, otherwize you must clause this distinct with call to close() or where() method

Returns:
 
     public M distinct(String ... fields) {
         boolean mustClose = false;
         FunctionDistinct f = new FunctionDistinct();
         if (fields != null && fields.length > 0) {
             mustClose = true;
             for (String fieldName : fields) {
                 f.addArgs(new FunctionFieldValue(nullfieldName));
             }
         }
         addFunction(f);
         if (mustClose) {
             close();
         }
         
         return this.asM();
     }

    
this distinct is auto closed if argument is not null

Parameters:
one use to differenciate this method with Element argument with same with String argument
fields other element
Returns:
 
     public M distinct(Element oneElement ... fields) {
         List<Stringl = new ArrayList<String>();
         if (one != null) {
             l.add(one.getValue());
         }
         if (fields != null) {
             for (Element e : fields) {
                 l.add(e.getValue());
             }
         }
         return distinct(l.toArray(new String[l.size()]));
     }

    
ajoute une methode definit par l'utilisateur, la syntaxe de methode est package.class#method. Il faut ensuite ajouter des arguments a la methode
 
     public M function(String methodObject ... args) {
         return function(methodnullargs);
     }
    
    
ajoute une methode definit par l'utilisateur, la syntaxe de methode est [package.class]#method. Il faut ensuite ajouter des arguments a la methode

Parameters:
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.
alias l'alias assigne au resultat
args les parametre de la fonction, si vide, il faut alors explicitement appeler close() pour fermer la definition de cette fonction.
 
     public M function(String methodString aliasObject ... args) {
         if (StringUtils.startsWith(method"#")) {
             method = this.getClass().getName() + method;
         }
         WikittyQueryFunctionWrapper f = new WikittyQueryFunctionWrapper(methodalias);
         boolean mustClose = false;
         if (args != null && args.length > 0) {
             mustClose = true;
             for (Object o : args) {
                 if (o instanceof WikittyQueryFunction) {
                     f.addArgs((WikittyQueryFunction)o);
                 } else {
                    f.addArgs(new FunctionValue(nullo));
                 }
             }
         }
         addFunction(f);
         if (mustClose) {
             close();
         }
         return this.asM();
     }
 
     ///////////////////////////////////////////////////////////////////////////
     //
     // Q U E R  Y   F L O W   C R E A T I O N
     //
     ///////////////////////////////////////////////////////////////////////////
 
     // eq(Wikitty|Date|Number|Boolean|String)
 
     static protected ConditionValue convertToConditionValue(Object o) {
         ConditionValue result;
         if (o instanceof ConditionValue) {
             result = (ConditionValue)o;
         } else {
             String s = WikittyUtil.toString(o);
             result = new ConditionValueString(s);
         }
         return result;
     }

    
Ajout d'une valeur soit pour une condition soit pour une function de la clause select

Parameters:
value
Returns:
 
     public M value(Object value) {
         Condition c = getOpenStack().peek();
         if (c instanceof Select) {
             FunctionValue f = new FunctionValue(nullvalue);
             addFunction(f);
             close();
         } else {
             ConditionValue v = convertToConditionValue(value);
             addCondition(v);
         }
         return this.asM();
     }

    
Ajoute une condition, cette condition est prise comme une condition terminal Si l'on veut continuer a construire la requete, il faut avoir ajouter avant une and(), or(), not(), containsOne(org.nuiton.wikitty.entities.Element)

Parameters:
c la condition a ajouter
Returns:
this with the c restriction added.
 
     public M condition(Condition c) {
         addCondition(ctrue);
         return this.asM();
     }

    
Parse et ajoute un bout de requete. Cette requete est prise comme une condition terminal si l'on veut continuer a construire la requete, il faut avoir ajouter avant une and(), or(), not(), containsOne(org.nuiton.wikitty.entities.Element)

Parameters:
query la requete a ajouter (peut-etre vide ou nul, dans ce cas, la condition utiliser est "true")
includeExtra copy offset, limit, depth found in query if true
Returns:
this with the c restriction added.
 
     public M parse(String queryboolean includeExtra) {
         if (StringUtils.isNotBlank(query)) {
             WikittyQuery filter = WikittyQueryParser.parse(query);
             addCondition(filter.getCondition(), true);
             if (includeExtra) {
                 WikittyQuery q = getQuery();
                 q.setOffset(filter.getOffset());
                 q.setLimit(filter.getLimit());
                 q.setWikittyFieldSearchDepth(filter.getWikittyFieldSearchDepth());
             }
         } else {
             addCondition(new True());
         }
         return this.asM();
     }

    
Parse et ajoute un bout de requete. Cette requete est prise comme une condition terminal si l'on veut continuer a construire la requete, il faut avoir ajouter avant une and(), or(), not(), containsOne(org.nuiton.wikitty.entities.Element)

Parameters:
query la requete a ajouter (peut-etre vide ou nul, dans ce cas, la condition utiliser est "true")
Returns:
this with the c restriction added.
 
     public M parse(String query) {
         return parse(queryfalse);
     }

    
Ajoute une contrainte qui cree les conditions en prenant comme exemple l'objet passer en parametre. Seuls les champs non null sont utilises ainsi que la liste des extensions de l'objet

Parameters:
w le wikitty a prendre comme exemple
Returns:
this with the w restriction added.
 
     public M wikitty(Wikitty w) {
         WikittyQueryMaker result = new WikittyQueryMaker().and();
 
         // result object must have same extension that wikitty example
         result.extContainsAll(w.getExtensionNames());
         
         for (String fqfieldName : w.fieldNames()) {
             Object value = w.getFqField(fqfieldName);
             if (value != null) {
                 FieldType type = w.getFieldType(fqfieldName);
                 if (type.isCollection()) {
                     result.containsAll(fqfieldName, (Collection<?>)value);
                 } else {
                     result.eq(fqfieldNamevalue);
                 }
             }
         }
         addCondition(result.getCondition());
 
         return this.asM();
     }

    
Ajoute une contrainte qui cree les conditions en prenant comme exemple l'objet passer en parametre. Seuls les champs non null sont utilises ainsi que la liste des extensions de l'objet

Parameters:
e l'objet a prendre comme exemple
Returns:
this with the e restriction added.
 
     public M wikitty(BusinessEntityImpl e) {
         Wikitty w = e.getWikitty();
         return wikitty(w);
     }

    
 
     public M containsAll(Element element) {
         addCondition(new ContainsAll(element));
         return this.asM();
     }

    
 
     public M containsAll(String element) {
         return containsAll(Element.get(element));
     }

    
Contains. Search on lists (multivalued fields) that a field contains all the values of the list given in parameter. Ex : The field with value [toto,titi,tutu] contains [titi,tutu] but not [titi,tutu,tata] Force l'ajout du containsAll en terminal (il n'y a pas besoin de faire de close()

Parameters:
element the element on which the restriction is put
values the values to search in the element
Returns:
this with the contains restriction added.
See also:
org.nuiton.wikitty.query.conditions.ContainsAll
 
     public <E> M containsAll(String fqfieldCollection<E> values) {
         return containsAll(Element.get(fqfield), values);
     }

    
Force l'ajout du containsAll en terminal (il n'y a pas besoin de faire de close()

 
     public <E> M containsAll(Element elementCollection<E> values) {
         containsAll(element);
         for (E e : values) {
             value(e);
         }
         close();
         return this.asM();
     }

    
Search on lists (multivalued fields) that a field contains all the values given in parameter. Ex : The field with value [toto,titi,tutu] contains [titi,tutu] but not [titi,tutu,tata] Ps : Use wildcards if you search for substrings. Force l'ajout du containsAll en terminal (il n'y a pas besoin de faire de close()

Parameters:
element the element on which the restriction is put
value1 first value to search in the field
values list of values to search in the field
Returns:
this with the contains restriction added.
See also:
org.nuiton.wikitty.query.conditions.ContainsAll
 
     public <E> M containsAll(String fqfield, E value1, E ... values) {
         List<E> l = new LinkedList<E>();
         l.add(value1);
         l.addAll(Arrays.asList(values));
         return containsAll(fqfieldl);
     }

    
 
     public M containsOne(Element element) {
         addCondition(new ContainsOne(element));
         return this.asM();
     }

    
 
     public M containsOne(String element) {
         return containsOne(Element.get(element));
     }

    
Search if a field is contained in the list of values in parameter Ex : The field with value titi is in [titi,tutu] but not in [tutu,tata] Force l'ajout du containsOne en terminal (il n'y a pas besoin de faire de close()

Parameters:
element the element on which the restriction is put
values list of values the field must be in
Returns:
this with the in restriction added.
See also:
org.nuiton.wikitty.query.conditions.ContainsOne
 
     public <E> M containsOne(String fqfieldCollection<E> values) {
         return containsOne(Element.get(fqfield), values);
     }

    
Force l'ajout du containsOne en terminal (il n'y a pas besoin de faire de close()

 
     public <E> M containsOne(Element elementCollection<E> values) {
         containsOne(element);
         for (E e : values) {
             value(e);
         }
         close();
         return this.asM();
     }

    
Search if a field is contained in the list of values in parameter Ex : The field with value titi is in [titi,tutu] but not in [tutu,tata] Ps : Use wildcards in the values if you search for substrings. Force l'ajout du containsAll en terminal (il n'y a pas besoin de faire de close()

Parameters:
element the element on which the restriction is put
value1 first value the field must be in
values list of values the field must be in
Returns:
this with the in restriction added.
See also:
org.nuiton.wikitty.query.conditions.ContainsOne
 
     public <E> M containsOne(String fqfield, E value1, E ... values) {
         List<E> l = new LinkedList<E>();
         l.add(value1);
         l.addAll(Arrays.asList(values));
         return containsOne(fqfieldl);
     }

    
 
     public M eq(Element element) {
         addCondition(new Equals(element));
         return this.asM();
     }

    
Equals. Restrict search so that the field value equals the parameter. You might use patterns in your equality.

Parameters:
element the field on which the search is made
value the value the element must be equals to
Returns:
this
See also:
org.nuiton.wikitty.query.conditions.Equals
 
     public M eq(String fqfieldObject value) {
         return eq(Element.get(fqfield), value);
     }

    
 
     public M eq(Element elementObject value) {
         ConditionValue s = convertToConditionValue(value);
         addCondition(new Equals(elements));
         return this.asM();
     }

    
 
     public M eqIgnoreCaseAndAccent(Element element) {
         addCondition(new Equals(elementtrue));
         return this.asM();
     }

    
Equals. Restrict search so that the field value equals the parameter. You might use patterns in your equality.

Parameters:
element the field on which the search is made
value the value the element must be equals to
Returns:
this
See also:
org.nuiton.wikitty.query.conditions.Equals
 
     public M eqIgnoreCaseAndAccent(String fqfieldObject value) {
         return eqIgnoreCaseAndAccent(Element.get(fqfield), value);
     }

    
 
     public M eqIgnoreCaseAndAccent(Element elementObject value) {
         ConditionValue s = convertToConditionValue(value);
         addCondition(new Equals(elementstrue));
         return this.asM();
     }

    
Extension equals. Restrict search to wikitties that got the extension in parameter.

Parameters:
s the extension to restrict the results to
Returns:
this with the exteq restriction added.
See also:
org.nuiton.wikitty.query.conditions.Equals
 
     public M exteq(String extensionName) {
         return eq(.extensionName);
     }

    
Id equals. Restrict search to wikitties that got the id in parameter.

Parameters:
value the id or wikitty to restrict the results to
Returns:
this with the ideq restriction added.
See also:
org.nuiton.wikitty.query.conditions.Equals
 
     public M ideq(Object idOrWikitty) {
         return eq(.idOrWikitty);
     }

    
Extension equals. Restrict search to wikitties that got all the extensions in parameter.

Parameters:
extensionNames list of the extension to restrict the results to
Returns:
this with the exteq restriction added.
See also:
org.nuiton.wikitty.query.conditions.ContainsAll
 
     public M extContainsAll(Collection<StringextensionNames) {
         return containsAll(.extensionNames);
     }

    
 
     public M extContainsAll(String ext1String ... exts) {
         List<Stringl = new LinkedList<String>();
         l.add(ext1);
         l.addAll(Arrays.asList(exts));
         return containsAll(.l);
     }

    
Extension equals. Restrict search to wikitties that got one of the extensions in parameter.

Parameters:
extensionNames list of the extension to restrict the results to
Returns:
this with the exteq restriction added.
See also:
org.nuiton.wikitty.query.conditions.ContainsAll
 
     public M extContainsOne(Collection<StringextensionNames) {
         return containsOne(.extensionNames);
     }

    
 
     public M extContainsOne(String ext1String ... exts) {
         List<Stringl = new LinkedList<String>();
         l.add(ext1);
         l.addAll(Arrays.asList(exts));
         return containsOne(.l);
     }

    
 
     public M ne(Element element) {
         addCondition(new NotEquals(element));
         return this.asM();
     }

    
Not equals. Restrict search to elements that are not equals to the value given in parameter.

Parameters:
fqfield the element on which the restriction is put
value the value the element must not be equals to.
Returns:
this with the neq restriction added.
See also:
org.nuiton.wikitty.query.conditions.NotEquals
 
     public M ne(String fqfieldObject value) {
         return ne(Element.get(fqfield), value);
     }

    
 
     public M ne(Element elementObject value) {
         ConditionValue s = convertToConditionValue(value);
         addCondition(new NotEquals(elements));
         return this.asM();
     }

    
 
     public M neIgnoreCaseAndAccent(Element element) {
         addCondition(new NotEquals(elementtrue));
         return this.asM();
     }

    
Not equals. Restrict search to elements that are not equals to the value given in parameter.

Parameters:
fqfield the element on which the restriction is put
value the value the element must not be equals to.
Returns:
this with the neq restriction added.
See also:
org.nuiton.wikitty.query.conditions.NotEquals
    public M neIgnoreCaseAndAccent(String fqfieldObject value) {
        return neIgnoreCaseAndAccent(Element.get(fqfield), value);
    }

    
    public M neIgnoreCaseAndAccent(Element elementObject value) {
        ConditionValue s = convertToConditionValue(value);
        addCondition(new NotEquals(elementstrue));
        return this.asM();
    }

    
Extension not equals. Restrict search to wikitties that do not get the extension given in parameter.

Parameters:
extensionName the extension that the wikitties must not have.
Returns:
this with the extneq restriction added.
See also:
org.nuiton.wikitty.query.conditions.NotEquals
    public M extne(String extensionName) {
        return ne(.extensionName);
    }

    
Id not equals. Restrict search to wikitties that do not have the id given in parameter.

Parameters:
idOrWikitty the id the wikitties must not have.
Returns:
this with the idne restriction added.
See also:
org.nuiton.wikitty.query.conditions.NotEquals
    public M idne(Object idOrWikitty) {
        return ne(.idOrWikitty);
    }

    
    public M gt(Element element) {
        addCondition(new Greater(element));
        return this.asM();
    }

    
Greater than. Search if an element value is greater than the parameter.

Parameters:
fqfield the element on which the restriction is put
value the value to be compared to
Returns:
this with the gt restriction added.
See also:
org.nuiton.wikitty.query.conditions.Greater
    public M gt(String fqfieldObject value) {
        return gt(Element.get(fqfield), value);
    }

    
    public M gt(Element elementObject value) {
        ConditionValue s = convertToConditionValue(value);
        addCondition(new Greater(elements));
        return this.asM();
    }

    
    public M ge(Element element) {
        addCondition(new GreaterOrEquals(element));
        return this.asM();
    }

    
Greater than or equals. Search if an element value is greater than or equals to the parameter.

Parameters:
fqfield the field on which the search is made
value the value to be compared to
Returns:
this with the ge restriction added.
See also:
org.nuiton.wikitty.query.conditions.GreaterOrEquals
    public M ge(String fqfieldObject value) {
        return ge(Element.get(fqfield), value);
    }

    
    public M ge(Element elementObject value) {
        ConditionValue s = convertToConditionValue(value);
        addCondition(new GreaterOrEquals(elements));
        return this.asM();
    }

    
    public M lt(Element element) {
        addCondition(new Less(element));
        return this.asM();
    }

    
Less than. Search if an element value is less than the parameter.

Parameters:
fqfield the element on which the restriction is put
value the value to be compared to
Returns:
this with the lt restriction added.
See also:
org.nuiton.wikitty.query.conditions.Less
    public M lt(String fqfieldObject value) {
        return lt(Element.get(fqfield), value);
    }

    
    public M lt(Element elementObject value) {
        ConditionValue s = convertToConditionValue(value);
        addCondition(new Less(elements));
        return this.asM();
    }

    
    public M le(Element element) {
        addCondition(new LessOrEquals(element));
        return this.asM();
    }

    
Less than or equals. Search if an element value is less than or equals to the parameter.

Parameters:
fqfield the element on which the restriction is put.
value the value to be compared to.
Returns:
this with the le restriction added.
See also:
org.nuiton.wikitty.query.conditions.LessOrEquals
    public M le(String fqfieldObject value) {
        return le(Element.get(fqfield), value);
    }

    
    public M le(Element elementObject value) {
        ConditionValue s = convertToConditionValue(value);
        addCondition(new LessOrEquals(elements));
        return this.asM();
    }

    
    public M bw(Element element) {
        addCondition(new Between(element));
        return this.asM();
    }

    
Between. Restrict search so that the element value is between the lower and upper values (it can also be equals).

Parameters:
fqfield the element on which the restriction is put.
lowerValue the lower bound.
upperValue the upper bound.
Returns:
this with the le restriction added.
See also:
org.nuiton.wikitty.query.conditions.Between
    public M bw(String fqfieldObject lowerValueObject upperValue) {
        return bw(Element.get(fqfield), lowerValueupperValue);
    }

    
    public M bw(Element elementObject lowerValueObject upperValue) {
        ConditionValue min = convertToConditionValue(lowerValue);
        ConditionValue max = convertToConditionValue(upperValue);
        addCondition(new Between(elementminmax));
        return this.asM();
    }

    
Starts with. Search if an element starts with the value in parameter.

Parameters:
fqfield the element on which the restriction is put.
value the value the element must start with.
Returns:
this with the sw restriction added.
See also:
org.nuiton.wikitty.query.conditions.Equals
    public M sw(String fqfieldString value) {
        return sw(Element.get(fqfield), value);
    }

    
    public M sw(Element elementString value) {
        addCondition(new Equals(elementvalue + "*"));
        return this.asM();
    }

    
Not starts with. Search if an element does not starts with the value in parameter.

Parameters:
fqfield the element on which the restriction is put.
value the value the element must not start with.
Returns:
this with the nsw restriction added.
See also:
org.nuiton.wikitty.query.conditions.NotEquals
    public M notsw(String fqfieldString value) {
        return notsw(Element.get(fqfield), value);
    }

    
    public M notsw(Element elementString value) {
        addCondition(new NotEquals(elementvalue + "*"));
        return this.asM();
    }

    
Ends with. Search if an element ends with the value in parameter.

Parameters:
fqfield the element on which the restriction is put
value the value the element must ends with.
Returns:
this with the ew restriction added.
See also:
org.nuiton.wikitty.query.conditions.Equals
    public M ew(String fqfieldObject value) {
        return ew(Element.get(fqfield), value);
    }

    
    public M ew(Element elementObject value) {
        addCondition(new Equals(element"*" + value));
        return this.asM();
    }

    
Not ends with. Search if an element does not ends with the value in parameter.

Parameters:
fqfield the element on which the restriction is put
value the value the element must not ends with.
Returns:
this with the notew restriction added.
See also:
org.nuiton.wikitty.query.conditions.NotEquals
    public M notew(String fqfieldObject value) {
        return notew(Element.get(fqfield), value);
    }

    
    public M notew(Element elementObject value) {
        addCondition(new NotEquals(element"*" + value));
        return this.asM();
    }

    
Keyword. Search if the value in parameter is present in any field of any extension.

Parameters:
value the value to find.
Returns:
this with the keyword restriction added.
See also:
org.nuiton.wikitty.query.conditions.Keyword
    public M keyword() {
        addCondition(new Keyword());
        return this.asM();
    }

    
Keyword. Search if the value in parameter is present in any field of any extension.

Parameters:
value the value to find.
Returns:
this with the keyword restriction added.
See also:
org.nuiton.wikitty.query.conditions.Keyword
    public M keyword(Object value) {
        ConditionValue s = convertToConditionValue(value);
        addCondition(new Keyword().addCondition(s));
        return this.asM();
    }

    
Is null. Check that a field is null.

Parameters:
fqfield the field that must be null.
Returns:
this with the isNull restriction added.
See also:
org.nuiton.wikitty.query.conditions.Null
    public M isNull(String fqfield) {
        return isNull(Element.get(fqfield));
    }

    
    public M isNull(Element element) {
        addCondition(new Null(element));
        return this.asM();
    }

    
Is not null. Check that a field is not null.

Parameters:
fqfield the field that must not be null.
Returns:
this with the isNotNull restriction added.
See also:
org.nuiton.wikitty.query.conditions.NotNull
    public M isNotNull(String fqfield) {
        return isNotNull(Element.get(fqfield));
    }

    
    public M isNotNull(Element element) {
        addCondition(new NotNull(element));
        return this.asM();
    }

    
False. Add a restriction that always return false.

Returns:
this with the rFalse restriction added.
See also:
org.nuiton.wikitty.query.conditions.False
    public M rFalse() {
        addCondition(new False());
        return this.asM();
    }

    
True. Add a restriction that always return true.

Returns:
this with the rTrue restriction added.
See also:
org.nuiton.wikitty.query.conditions.True
    public M rTrue() {
        addCondition(new True());
        return this.asM();
    }

    
    public M like(Element element) {
        addCondition(new Like(element));
        return this.asM();
    }

    
Like. Check that a string is present in a field. For example "tric" is present in "Restriction".

Parameters:
fqfield the element on which the restriction is put
value
Returns:
this
See also:
org.nuiton.wikitty.query.conditions.Like
    public M like(String fqfieldObject value) {
        return like(Element.get(fqfield), value);
    }

    
    public M like(Element elementObject value) {
        ConditionValue s = convertToConditionValue(value);
        Like c = new Like(elements);
        addCondition(c);
        return this.asM();
    }

    
    public M unlike(Element element) {
        addCondition(new Unlike(element));
        return this.asM();
    }

    
Unlike.

Parameters:
fqfield the element on which the restriction is put
value
searchAs
Returns:
this
See also:
org.nuiton.wikitty.query.conditions.Unlike
    public M unlike(String fqfieldObject value) {
        return unlike(Element.get(fqfield), value);
    }

    
    public M unlike(Element elementObject value) {
        ConditionValue s = convertToConditionValue(value);
        Unlike c = new Unlike(elements);
        addCondition(c);
        return this.asM();
    }

    
Not (sub query). To close this sub query you must used close()
  • ex: WikittyQueryMaker().not().rTrue().close().and().rTrue().rFalse().close().or().rTrue().rFalse().close();

  •     public M not() {
            Condition child = new Not();
            addCondition(child);
            return this.asM();
        }

        
    Or (sub query). To close this sub query you must used close()
  • ex: WikittyQueryMaker().not().rTrue().close().and().rTrue().rFalse().close().or().rTrue().rFalse().close();

  •     public M or() {
            Condition child = new Or();
            addCondition(child);
            return this.asM();
        }

        
    And (sub query). To close this sub query you must used close()
  • ex: WikittyQueryMaker().not().rTrue().close().and().rTrue().rFalse().close().or().rTrue().rFalse().close();

  •     public M and() {
            Condition child = new And();
            addCondition(child);
            return this.asM();
        }

        
    Add org.nuiton.wikitty.query.conditions.Select, this condition must be first or

    Parameters:
    element le champs dont il faut extraire les donnees
    Returns:
    this
    See also:
    org.nuiton.wikitty.query.conditions.Select
    //    public M select() {
    //        return select(null);
    //    }
        /*
         * @see {@link Select}
         */
        public M select() {
            return select((WikittyQueryFunction)null);
        }
        /*
         * @see {@link Select}
         */
        public M select(WikittyQueryFunction f) {
            Condition child = new Select(f);
            addCondition(child);
            return this.asM();
        }
        /*
         * @see {@link Select}
         */
        public M select(String e) {
            return select(Element.get(e));
        }
        /*
         * @see {@link Select}
         */
        public M select(Element e) {
            return select(new FunctionFieldValue(nulle.getValue()));
        }
    //    public M addFunction(WikittyQueryFunction f) {
    //        // ajout function sur select ou args de function
    //        // close sur function
    //    }

        
    Close last non terminal condition (or, and, not, in). Or Last Function in select clause
  • ex: WikittyQueryMaker().not().rTrue().close().and().rTrue().rFalse().close().or().rTrue().rFalse().close();

    Returns:
  •     public M close() {
            Condition c = getOpenStack().peek();
            if (c instanceof Select && f != null) {
                if (.size() == 1) {
                    // si on enleve l'element, il n'y a plus rien, ce close est donc
                    // l'equivalent d'un Where
                    where();
                } else {
                     // on depile (il avait deja ete ajoute au parent, rien d'autre a faire)
                    .pop();
                }
            } else {
                getOpenStack().pop(); // on en ferme 1 obligatoirement
                // on cherche a en fermer plus
                closeIfNecessary();
            }
            return this.asM();
        }

        
    Ferme la construction de la condition et la met en place dans la WikittyQuery qui sera retournee

    Returns:
    un objet WikittyQuery soit un nouveau soit celui passe dans le constructeur
        public WikittyQuery end() {
            WikittyQuery result = getQuery();
            result.setCondition(getCondition());
            // on interdit les modifications futur
             = null;
            
            return result;
        }