WhereClause.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2011 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package org.turro.elephant.db;
 
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.persistence.Query;
import org.turro.string.Strings;
 
public class WhereClause {
 
  private String clause = "";
  private ArrayList values = new ArrayList();
  private Map<String, Object> namedValues = new HashMap<>();
  // like options
  private String prefix = "and", fieldOcurrence = "and";
  private int uniqueSuffix = 0;
  private Map<String, Object> attributes = new HashMap<>();
  private String orderByClause, groupByClause;
  private boolean useNative;
  private Class resultClass;
 
  public WhereClause() {
  }
 
  public WhereClause(String prefix) {
    this.prefix = prefix;
  }
 
  public Map<String, Object> getAttributes() {
    return attributes;
  }
 
  public void addClause(String clause) {
    this.clause += " " + clause;
  }
  
  public void addClauseIfNotExists(String clause) {
    if(this.clause == null || !this.clause.contains(clause)) {
      this.clause += " " + clause;
    }
  }
  
  public void addInRange(String operator, String startField, String endField, String attribute, Date date) {
    addClause(operator + "(");
    addClause("(" + startField + " is null or " + startField + " >= :" + attribute + ")");
    addClause("and (" + endField + " is null or " + endField + " <= :" + attribute + ")");
    addClause(")");
    addNamedValue(attribute, date);
  }
 
  public void addValue(Object value) {
    values.add(value);
  }
  
  public void addNamedValue(String name, Object value) {
    namedValues.put(name, value);
  }
 
  public void addLikeFields(String[] fields, String value) {
    if(value == null) return;
    if(value.startsWith("=") || value.startsWith("?")) {
      SQLHelper.getWhereClause(this, fields, value);
    } else if(value.startsWith("\"") && value.endsWith("\"")) {
      value = value.substring(1, value.length() - 1);
      SQLHelper.getWhereClause(this, fields,
              (value == null ? "" : value.replaceAll("\\*", "%").replaceAll("\\?", "_")), null);
    } else {
      SQLHelper.getWhereClause(this, fields,
              (value == null ? "" : value.replaceAll("\\*", "%").replaceAll("\\?", "_")), " +");
    }
  }
 
  public Map<String, Object> getNamedValues() {
    return namedValues;
  }
 
  public List<Object> getNamedValues(String ... name) {
    ArrayList<Object> list = new ArrayList<>();
    for(String n : name) {
      if(namedValues.containsKey(n)) list.add(namedValues.get(n));
    } 
    return list;
  }
 
  public int getValueCount() {
    return values.size();
  }
 
  public Object getValue(int index) {
    return values.get(index);
  }
 
  public String getClause() {
    if(!Strings.isBlank(clause)) {
      if(!Strings.isBlank(groupByClause) && clause.toLowerCase().contains("group by")) {
        clause += " " + groupByClause;
      }
      if(!Strings.isBlank(orderByClause) && clause.toLowerCase().contains("order by")) {
        clause += " " + orderByClause;
      }
    }
    if(clause.matches(".*\\{[^\\}]+\\}.*")) {
      clause = clause.replaceAll("\\{([^\\}]+)\\}", useNative ? "*" : "$1");
    }
    return clause;
  }
 
  public void setClause(String clause) {
    this.clause = clause;
  }
 
  public void setOrderByClause(String orderByClause) {
    this.orderByClause = orderByClause;
  }
 
  public void setGroupByClause(String groupByClause) {
    this.groupByClause = groupByClause;
  }
 
  public boolean isUseNative() {
    return useNative;
  }
 
  public void setUseNative(boolean useNative) {
    this.useNative = useNative;
  }
 
  public Class getResultClass() {
    return resultClass;
  }
 
  public void setResultClass(Class resultClass) {
    this.resultClass = resultClass;
  }
 
  public int getUniqueSuffix() {
    return uniqueSuffix++;
  }
 
  public Object[] getValues() {
    return values.toArray(new Object[0]);
  }
 
  @Deprecated
  public void setParameters(Query q, int start) {
    for (int i = 0; i < getValueCount(); i++) {
      q.setParameter(i + start, getValue(i));
    }
  }
 
  public void setNamedParameters(Query q) {
    for (Map.Entry<String, Object> e : namedValues.entrySet()) {
      q.setParameter(e.getKey(), e.getValue());
    }
  }
 
  public String getFieldOcurrence() {
    return fieldOcurrence;
  }
 
  public void setFieldOcurrence(String fieldOcurrence) {
    if(fieldOcurrence == null) fieldOcurrence = "and";
    this.fieldOcurrence = fieldOcurrence;
  }
 
  public String getPrefix() {
    return prefix;
  }
 
  public void setPrefix(String prefix) {
    if(prefix == null) prefix = "and";
    this.prefix = prefix;
  }
  
  private static final int IN_LIMIT = 500;
  
  public void addNotIn(String operator, String field, List values) {
    addIn(operator, field + " not", values);
  }
  
  public void addIn(String operator, String field, List values) {
    if(values == null || values.isEmpty()) {
      addClause((operator != null ? operator + " 1=2" : "1=2"));
    } else {
      int listSize = values.size();
      if(listSize <= IN_LIMIT) {
        String var = getUniqueVariable("intids");
        addClause((operator != null ? operator + " " : "") + field + " in (:"+ var + ")");
        addNamedValue(var, values);
      } else {
        addClause((operator != null ? operator + " (" : "("));
        String sep = "";
        for (int i = 0; i < listSize; i += IN_LIMIT) {
          String var = getUniqueVariable("intids");
          List subList = (listSize > i + IN_LIMIT) ?
                          values.subList(i, (i + IN_LIMIT)) :
                          values.subList(i, listSize);
          addClause(sep + field + " in (:" + var + ")");
          addNamedValue(var, subList);
          sep = "or ";
        }
        addClause(")");
      }
    }
  }
 
  public String getUniqueVariable(String prefix) {
    return prefix + "wcvar" + getUniqueSuffix();
  }
  
  /* Factory */
  
  public static WhereClause getFromClause(String clause) {
    WhereClause wc = new WhereClause();
    wc.addClause(clause);
    return wc;
  }
  
}