SQLQueryObjectCore.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */



  23. package org.openspcoop2.utils.sql;

  25. import java.security.SecureRandom;
  26. import java.util.ArrayList;
  27. import java.util.Date;
  28. import java.util.HashMap;
  29. import java.util.Iterator;
  30. import java.util.List;
  31. import java.util.Map;

  33. import org.openspcoop2.utils.TipiDatabase;


  36. /**
  37.  * Classe dove vengono forniti utility per la conversione di comandi SQL per database diversi 
  38.  * 
  39.  *
  40.  * @author Poli Andrea (apoli@link.it)
  41.  * @author $Author$
  42.  * @version $Rev$, $Date$
  43.  */
  44. public abstract class SQLQueryObjectCore implements ISQLQueryObject{

  46.     private static final String LA_COLONNA_PREFIX = "La colonna ";
  47.     private static final String TABELLA_PREFIX = "Tabella ";
  48.     private static final String WHERE_CONDITION_PREFIX = "Where Condition ";
  49.     private static final String FIELD_NAME_PREFIX = "Field name ";
  50.     
  51.     private static final String ALIAS_TABELLA_INDICATO_NON_ESISTE = "L'alias indicato non corrisponde ad un alias effettivo associato ad una tabella";
  52.     private static final String NESSUN_FIELD_IMPOSTATO = "Nessun field impostato";
  53.     private static final String GIA_ESISTENTE_TRA_CONDIZIONI_WHERE = " gia' esistente tra le condizioni di where";
  54.     private static final String FIELD_NAME_IS_NULL_OR_EMPTY = "Field name is null or empty string";
  55.     protected static final String CONDIZIONI_ORDER_BY_RICHESTE = "Condizioni di OrderBy richieste";
  56.     protected static final String TABELLA_RICERCA_FROM_NON_DEFINITA = "Tabella di ricerca (... FROM Table ...) non definita";
  57.     
  58.     private static final String NOME_TABELLA_DEVE_ESSERE_DIVERSO_NULL = "nomeTabella non puo' essere null";
  59.     protected static final String FIELD_DEVE_ESSERE_DIVERSO_NULL = "field non puo' essere null";
  60.     private static final String IS_NULL_CONDITION_DEVE_ESSERE_DIVERSO_NULL = "IsNullCondition field non puo' essere null";
  61.     
  62.     private static final String LOWER_PREFIX = "( lower(";
  63.     private static final String ESCAPE_SEPARATOR = " ESCAPE ";
  64.     private static final String LIKE_SEPARATOR = " LIKE ";
  65.     
  66.     protected static final String FROM_SEPARATOR = " FROM ";
  67.     protected static final String FROM_SEPARATOR_APERTURA = " FROM ( ";
  68.     protected static final String WHERE_SEPARATOR = " WHERE ";
  69.     protected static final String AND_SEPARATOR = " AND ";
  70.     protected static final String OR_SEPARATOR = " OR ";
  71.     protected static final String ASC_SEPARATOR = " ASC ";
  72.     protected static final String DESC_SEPARATOR = " DESC ";
  73.     protected static final String GROUP_BY_SEPARATOR = " GROUP BY ";
  74.     protected static final String ORDER_BY_SEPARATOR = " ORDER BY ";
  75.     protected static final String LIMIT_SEPARATOR = " LIMIT ";
  76.     protected static final String NOT_SEPARATOR_APERTURA = " NOT ( ";
  77.     
  78.     protected static final String SELECT_SEPARATOR_CON_INIZIO_APERTURA = " ( SELECT ";
  79.     
  80.     protected static final String AS_SUBQUERY_SUFFIX = " ) as subquery";
  81.     
  82.     private static SecureRandom rndEngine = null;
  83.     private static synchronized void initRandom() {
  84.         if(rndEngine==null) {
  85.             rndEngine = new SecureRandom();
  86.         }
  87.     }
  88.     protected static java.util.Random getRandom() {
  89.         if(rndEngine==null) {
  90.             initRandom();
  91.         }
  92.         return rndEngine;
  93.     }
  94.     
  95.     /** List di Field esistenti: i nomi dei fields impostati (se e' stato utilizzato un alias ritorna comunque il nome della colonna) */
  96.     List<String> fields = new ArrayList<>();
  97.     /** List di NomiField esistenti: i nomi dei fields impostati (se e' stato utilizzato un alias ritorna il valore dell'alias) */
  98.     List<String> fieldNames = new ArrayList<>();
  99.     /** Mapping tra alias e indicazione se e' una function: i nomi dei fields impostati (se e' stato utilizzato un alias ritorna il valore dell'alias) */
  100.     Map<String, Boolean> fieldNameIsFunction = new HashMap<>();
  101.     /** Mapping tra alias (key) e field names (value) (sono presenti i mapping solo per le colonne per cui e' stato definito un alias) */
  102.     Map<String, String> alias = new HashMap<>();
  103.     
  104.     /** List di Tabelle esistenti */
  105.     List<String> tables = new ArrayList<>();
  106.     List<String> tableNames = new ArrayList<>();
  107.     List<String> tableAlias = new ArrayList<>();
  108.     
  109.     /** List di Field esistenti */
  110.     List<String> conditions = new ArrayList<>();
  111.     public int sizeConditions(){
  112.         return this.conditions.size();
  113.     }
  114.     
  115.     /** List di indici forzati */
  116.     List<String> forceIndexTableNames = new ArrayList<>();
  117.     
  118.     /** OperatorLogic */
  119.     boolean andLogicOperator = false;
  120.     
  121.     /** Not */
  122.     boolean notBeforeConditions = false;
  123.     
  124.     /** GroupBy di Field esistenti */
  125.     private List<String> groupBy = new ArrayList<>();
  126.     
  127.     /** OrderBy di Field esistenti */
  128.     List<String> orderBy = new ArrayList<>();
  129.     Map<String, Boolean> orderBySortType = new HashMap<>();
  130.     
  131.     /** Tipo di ordinamento */
  132.     boolean sortTypeAsc = true;
  133.     
  134.     /** Distinct */
  135.     private boolean distinct = false;
  136.     
  137.     /** Limit */
  138.     int limit = -1;
  139.     /** Offset */
  140.     int offset = -1;

  142.     /** SelectForUpdate */
  143.     boolean selectForUpdate = false;
  144.     
  145.     /* UPDATE */
  146.     /** List di Field per l'update */
  147.     List<String> updateFieldsName = new ArrayList<>();
  148.     List<String> updateFieldsValue = new ArrayList<>();
  149.     /** Tabella per l'update */
  150.     String updateTable = null;

  152.     /* INSERT */
  153.     /** List di Field per l'insert */
  154.     List<String> insertFieldsName = new ArrayList<>();
  155.     List<String> insertFieldsValue = new ArrayList<>();
  156.     /** Tabella per l'insert */
  157.     String insertTable = null;

  159.     /* TipoDatabase */
  160.     private TipiDatabase tipoDatabase;

  162.     /* preCheck */
  163.     private boolean precheckQuery = true;
  164.     public void setPrecheckQuery(boolean precheckQuery) {
  165.         this.precheckQuery = precheckQuery;
  166.     }

  168.     // Increment
  169.     private int serial = 0;
  170.     protected synchronized int getSerial(){
  171.         this.serial++;
  172.         return this.serial;
  173.     }

  175.     // Force to false SelectForUpdate in CRUD Method
  176.     private boolean forceSelectForUpdateDisabledForNotQueryMethod = false; // viene usato nel progetto generic forzato a true per JDBC_SQLObjectFactory
  177.     public void setForceSelectForUpdateDisabledForNotQueryMethod(boolean forceSelectForUpdateDisabledForNotQueryMethod) {
  178.         this.forceSelectForUpdateDisabledForNotQueryMethod = forceSelectForUpdateDisabledForNotQueryMethod;
  179.     }


  182.     // COSTRUTTORE
  183.     protected SQLQueryObjectCore(TipiDatabase tipoDatabase){
  184.         this.tipoDatabase = tipoDatabase;
  185.     }
  186.     
  187.     




  192.     // UTILITIES

  194.     protected void precheckBuildQuery() throws SQLQueryObjectException{

  196.         if(!this.precheckQuery){
  197.             return;
  198.         }

  200.         // Check Offset
  201.         if(this.offset>=0 &&
  202.             this.orderBy.isEmpty()){
  203.             throw new SQLQueryObjectException("Condizioni di OrderBy richieste");
  204.         }
  205.         
  206.         // Check GroupBy
  207.         precheckBuildQueryGroupBy();
  208.         
  209.         // Check Select For Update
  210.         if(this.selectForUpdate){
  211.             if(this.groupBy!=null && !this.groupBy.isEmpty()){
  212.                 throw new SQLQueryObjectException("Non è possibile abilitare il comando 'selectForUpdate' se viene utilizzata la condizione di GROUP BY");
  213.             }
  214.             else if(this.distinct){
  215.                 throw new SQLQueryObjectException("Non è possibile abilitare il comando 'selectForUpdate' se viene utilizzata la clausola DISTINCT");
  216.             }
  217.             else if(this.limit>=0){
  218.                 throw new SQLQueryObjectException("Non è possibile abilitare il comando 'selectForUpdate' se viene utilizzata la clausola LIMIT");
  219.             }
  220.             else if(this.offset>=0){
  221.                 throw new SQLQueryObjectException("Non è possibile abilitare il comando 'selectForUpdate' se viene utilizzata la clausola OFFSET");
  222.             }
  223.         }
  224.     }
  225.     private void precheckBuildQueryGroupBy() throws SQLQueryObjectException{
  226.         if(this.groupBy!=null && !this.groupBy.isEmpty()){

  228.             // verifico che tutte le condizioni di order by siano presente anche nei field di group by
  229.             precheckBuildQueryGroupByOrderBy();

  231.             // verifico che tutte le condizioni di group by siano presenti anche nei field
  232.             for (String groupByCheck : this.groupBy) {
  233.                 boolean exists = false;
  234.                 for (String field : this.fields) {
  235.                     if(normalizeField(groupByCheck).equals(normalizeField(field))){
  236.                         exists = true;
  237.                         break;
  238.                     }
  239.                 }
  240.                 if(!exists){
  241.                     throw new SQLQueryObjectException(LA_COLONNA_PREFIX+groupByCheck+" utilizzata nella condizione di GROUP BY deve essere anche selezionato come select field");
  242.                 }
  243.             }
  244.         }
  245.     }
  246.     private void precheckBuildQueryGroupByOrderBy() throws SQLQueryObjectException{
  247.         if(!this.orderBy.isEmpty()){
  248.             for (String order : this.orderBy) {
  249.                 precheckBuildQueryGroupByOrderBy(order);
  250.             }
  251.         }
  252.     }
  253.     private void precheckBuildQueryGroupByOrderBy(String order) throws SQLQueryObjectException{
  254.         boolean exists = false;
  255.         for (String groupByCheck : this.groupBy) {
  256.             if(normalizeField(groupByCheck).equals(normalizeField(order))){
  257.                 exists = true;
  258.                 break;
  259.             }
  260.         }
  261.         if(!exists){
  262.             String orderField = normalizeField(order);
  263.             try{
  264.                 if(this.isFieldNameForFunction(orderField)==null || (!this.isFieldNameForFunction(orderField).booleanValue())){
  265.                     throw new SQLQueryObjectException(LA_COLONNA_PREFIX+order+" utilizzata nella condizione di ORDER BY deve apparire anche in una condizione di GROUP BY");
  266.                 }
  267.             }catch(SQLQueryObjectException sqlObject){
  268.                 throw new SQLQueryObjectException(LA_COLONNA_PREFIX+order+" utilizzata nella condizione di ORDER BY deve apparire anche in una condizione di GROUP BY",sqlObject);
  269.             }
  270.         }
  271.     }

  273.     protected String normalizeField(String field){
  274.         return this.normalizeField(field, true);
  275.     }
  276.     protected String normalizeField(String field, boolean firstSearchFromAliasesField){

  278.         if(firstSearchFromAliasesField){
  279.             // 1. Viene fornito il nome della colonna su database.
  280.             // Potrebbe essere stato mappato con un alias nella select field.
  281.             // In tal caso deve essere ricavato ed utilizzato l'alias
  282.             Iterator<String> itRicercaAlias = this.fields.iterator();
  283.             while(itRicercaAlias.hasNext()){
  284.                 String fieldRicercaAliasa = itRicercaAlias.next();
  285.                 String [] split = null;
  286.                 if(fieldRicercaAliasa.contains(" as ")){
  287.                     split = fieldRicercaAliasa.split(" as ");
  288.                 }else if(fieldRicercaAliasa.contains(" As ")){
  289.                     split = fieldRicercaAliasa.split(" As ");
  290.                 }else if(fieldRicercaAliasa.contains(" aS ")){
  291.                     split = fieldRicercaAliasa.split(" aS ");
  292.                 }else if(fieldRicercaAliasa.contains(" AS ")){
  293.                     split = fieldRicercaAliasa.split(" AS ");
  294.                 }else if(fieldRicercaAliasa.contains(" ")){
  295.                     split = fieldRicercaAliasa.split(" ");
  296.                 }else if(fieldRicercaAliasa.contains(this.getDefaultAliasFieldKeyword())){
  297.                     split = fieldRicercaAliasa.split(this.getDefaultAliasFieldKeyword());
  298.                 }
  299.                 if(split==null){
  300.                     List<String> aliases = this.getSupportedAliasesField();
  301.                     if(aliases!=null && !aliases.isEmpty()){
  302.                         for (String aliasCheck : aliases) {
  303.                             if(fieldRicercaAliasa.contains(aliasCheck)){
  304.                                 split = fieldRicercaAliasa.split(aliasCheck);
  305.                                 break;
  306.                             }
  307.                         }
  308.                     }
  309.                 }
  310.                 if(split!=null && split.length==2){
  311.                     split[0] = split[0].trim();
  312.                     split[1] = split[1].trim();
  313.                     if(field.equals(split[0])){
  314.                         return split[1];
  315.                     }
  316.                 }
  317.             }
  318.         }

  320.         // Alcuni valori sono standard dei vendor dei database (es. gestione delle date)
  321.         // Il problema è che se contengono dei '.' o dei caratteri alias rientrano erroneamnete nei punti 2 e 3 dove invece non dovrebbero rientraci.
  322.         // Per questo motivo viene quindi prima richiesto al vendor se effettuare o meno la classica normalizzazione del field in base a tali valori
  323.         // sul field in essere
  324.         if(!this.continueNormalizeField(field)){
  325.             return field;
  326.         }
  327.         
  328.         // 2. Altrimenti devo verificare se vi e' un prefisso di tabella davanti
  329.         // Devono essere eliminati le TABELLE. e lasciare solo il field
  330.         int indexOf = field.indexOf(".");
  331.         if( (indexOf!=-1) && ((indexOf+1)<field.length()) ){
  332.             field = field.substring(indexOf+1);
  333.         }

  335.         // 3. Anche se ho eliminato il prefisso della tabella, potrei avere come field una stringa tipo 'colonna as alias'
  336.         // In tal caso devo tornare solo alias.
  337.         List<String> aliasModeSupportati = new ArrayList<>();
  338.         for (Iterator<?> iterator = this.getSupportedAliasesField().iterator(); iterator.hasNext();) {
  339.             aliasModeSupportati.add((String)iterator.next());
  340.         }
  341.         if(!aliasModeSupportati.contains(" ")){
  342.             aliasModeSupportati.add(" ");
  343.         }
  344.         if(!aliasModeSupportati.contains(" as ")){
  345.             aliasModeSupportati.add(" as ");
  346.         }
  347.         // itero su tutti gli alias (lastIndexOf utile per i casi di min/max/avg/sum timestamp field dove vengono usato anche altri alias internamente)
  348.         for (Iterator<?> iterator = aliasModeSupportati.iterator(); iterator.hasNext();) {
  349.             String aliasCheck = (String) iterator.next();
  350.             int aliasLength = aliasCheck.length(); //4
  351.             // Inoltre se vi sono alias, devono essere eliminati i field davanti agli alias e lasciati solo gli alias:
  352.             // Es. SCORRETTO :  SELECT id as IDAlias from (select id as IDAlias...)
  353.             // Es. CORRETTO :  SELECT IDAlias from (select id as IDAlias...)
  354.             String fLowerCase = field.toLowerCase();
  355.             /**indexOf = fLowerCase.lastIndexOf(" as ");*/
  356.             indexOf = fLowerCase.lastIndexOf(aliasCheck);
  357.             if( (indexOf!=-1) && ((indexOf+aliasLength)<field.length()) ){
  358.                 field = field.substring(indexOf+aliasLength);
  359.                 field = field.trim();
  360.                 break;
  361.             }
  362.         }
  363.         return field;   

  365.     }
  366.     protected boolean continueNormalizeField(String normalizeField){
  367.         
  368.         // Alcuni valori sono standard dei vendor dei database (es. gestione delle date)
  369.         // Il problema è che se contengono dei '.' o dei caratteri alias rientrano erroneamnete nei punti 2 e 3 della normalizzazione
  370.         // Per questo motivo viene quindi prima richiesto al vendor se effettuare o meno la classica normalizzazione del field in base a tali valori
  371.         // sul field in essere
  372.         
  373.         // Vedere quali database sovrascrivono questo metodo
  374.         // Ad esempio SQLServer
  375.         
  376.         if(normalizeField!=null) {
  377.             // nop
  378.         }
  379.         
  380.         return true;
  381.         
  382.     }
  383.     
  384.     protected String getCaseCondition(Case caseValue) throws SQLQueryObjectException {
  385.         if(caseValue==null) {
  386.             throw new SQLQueryObjectException("Field caseValue is null");
  387.         }
  388.         if(caseValue.getValori()==null || caseValue.getValori().isEmpty() || 
  389.                 caseValue.getCondizioni()==null || caseValue.getCondizioni().isEmpty()) {
  390.             throw new SQLQueryObjectException("Field caseValue non contiene condizioni");
  391.         }
  392.         if(caseValue.getValori().size()!=caseValue.getCondizioni().size()) {
  393.             throw new SQLQueryObjectException("Field caseValue contiene condizioni con  un numero di valori differenti dalle condizioni di where?");
  394.         }
  395.         if(caseValue.getTipoColonna()==null) {
  396.             throw new SQLQueryObjectException("Field caseValue non contiene il tipo della colonna");
  397.         }
  398.             
  399.         StringBuilder bf = new StringBuilder();
  400.         bf.append("CASE");
  401.         for (int i = 0; i < caseValue.getValori().size(); i++) {
  402.             String valore = caseValue.getValori().get(i);
  403.             String condizione = caseValue.getCondizioni().get(i);
  404.             bf.append(" WHEN ").append(condizione);
  405.             bf.append(" THEN ");
  406.             bf.append(getPrefixCastValue(caseValue.getTipoColonna(),caseValue.getDimensioneColonna()));
  407.             if(caseValue.isStringValueType()){
  408.                 bf.append("'");
  409.                 bf.append(escapeStringValue(valore));
  410.                 bf.append("'");
  411.             }
  412.             else{
  413.                 bf.append(valore);
  414.             }
  415.             bf.append(getSuffixCastValue(caseValue.getTipoColonna(),caseValue.getDimensioneColonna()));
  416.         }
  417.         if(caseValue.getValoreDefault()!=null) {
  418.             bf.append(" ELSE ");
  419.             bf.append(getPrefixCastValue(caseValue.getTipoColonna(),caseValue.getDimensioneColonna()));
  420.             if(caseValue.isStringValueType()){
  421.                 bf.append("'");
  422.                 bf.append(escapeStringValue(caseValue.getValoreDefault()));
  423.                 bf.append("'");
  424.             }
  425.             else{
  426.                 bf.append(caseValue.getValoreDefault());
  427.             }
  428.             bf.append(getSuffixCastValue(caseValue.getTipoColonna(),caseValue.getDimensioneColonna()));
  429.         }
  430.         bf.append(" END");
  431.                     
  432.         return bf.toString();
  433.     }






  440.     // SELECT FIELDS NORMALI

  442.     /**
  443.      * Aggiunge un field alla select, se non sono presenti field, viene utilizzato '*'
  444.      * es: SELECT nomeField FROM ....
  445.      * 
  446.      * @param nomeField Nome del Field
  447.      */
  448.     @Override
  449.     public ISQLQueryObject addSelectField(String nomeField) throws SQLQueryObjectException{
  450.         return this.addSelectField(null,nomeField);
  451.     }
  452.     /**
  453.      * Aggiunge un field alla select, se non sono presenti field, viene utilizzato '*'
  454.      * es: SELECT nomeTabella.nomeField FROM ....
  455.      * 
  456.      * @param nomeTabella Nome della tabella su cui reperire il field
  457.      * @param nomeField Nome del Field
  458.      */
  459.     @Override
  460.     public ISQLQueryObject addSelectField(String nomeTabella,String nomeField) throws SQLQueryObjectException{
  461.         return this.engineAddSelectField(nomeTabella,nomeField,null,true,false);
  462.     }
  463.     /**
  464.      * Aggiunge un field alla select, se non sono presenti field, viene utilizzato '*'
  465.      * es: SELECT nomeField FROM ....
  466.      * 
  467.      * @param nomeField Nome del Field
  468.      */
  469.     @Override
  470.     public ISQLQueryObject addSelectAliasField(String nomeField,String alias) throws SQLQueryObjectException{
  471.         return this.engineAddSelectField(null,nomeField,alias,true,false);
  472.     }
  473.     /**
  474.      * Aggiunge un field alla select, se non sono presenti field, viene utilizzato '*'
  475.      * es: SELECT nomeTabella.nomeField FROM ....
  476.      * 
  477.      * @param nomeTabella Nome della tabella su cui reperire il field
  478.      * @param nomeField Nome del Field
  479.      */
  480.     @Override
  481.     public ISQLQueryObject addSelectAliasField(String nomeTabella,String nomeField,String alias) throws SQLQueryObjectException{
  482.         return this.engineAddSelectField(nomeTabella,nomeField,alias,true,false);
  483.     }




  488.     // SELECT FIELDS COALESCE

  490.     /**
  491.      * Aggiunge un field alla select definendolo tramite la funzione coalesce
  492.      * es: SELECT coalesce(nomeField, 'VALORE') as alias FROM ....
  493.      * 
  494.      * @param nomeField Nome del Field
  495.      * @param alias Alias
  496.      * @param valore Valore utilizzato in caso il campo sia null
  497.      */
  498.     @Override
  499.     public ISQLQueryObject addSelectCoalesceField(String nomeField,String alias,String valore) throws SQLQueryObjectException{
  500.         return engineAddSelectField(null, nomeField, alias, true, "coalesce(",",'"+escapeStringValue(valore)+"')",true);
  501.     }

  503.     /**
  504.      * Aggiunge un field alla select definendolo tramite la funzione coalesce
  505.      * es: SELECT coalesce(nomeTabella.nomeField, 'VALORE') as alias FROM ....
  506.      * 
  507.      * @param aliasTabella Alias della tabella su cui reperire il field
  508.      * @param nomeField Nome del Field
  509.      * @param alias Alias
  510.      * @param valore Valore utilizzato in caso il campo sia null
  511.      */
  512.     @Override
  513.     public ISQLQueryObject addSelectCoalesceField(String aliasTabella,String nomeField,String alias,String valore) throws SQLQueryObjectException{
  514.         if(!this.tableAlias.contains(aliasTabella)){
  515.             throw new SQLQueryObjectException(ALIAS_TABELLA_INDICATO_NON_ESISTE);
  516.         }
  517.         return engineAddSelectField(aliasTabella, nomeField, alias, true, "coalesce(",",'"+escapeStringValue(valore)+"')",true);
  518.     }

  520.     
  521.     
  522.     
  523.     // SELECT FIELDS CASE
  524.     
  525.     /**
  526.      * Aggiunge un field alla select definendolo tramite la funzione coalesce
  527.      * es: SELECT coalesce(nomeField, 'VALORE') as alias FROM ....
  528.      * 
  529.      * @param caseField Case
  530.      * @param alias Alias
  531.      */
  532.     @Override
  533.     public ISQLQueryObject addSelectCaseField(Case caseField, String alias) throws SQLQueryObjectException{
  534.         
  535.         if(alias==null || "".equals(alias))
  536.             throw new SQLQueryObjectException("Alias is null or empty string");
  537.         
  538.         String caseValue = this.getCaseCondition(caseField);
  539.         
  540.         String field = "("+caseValue+")"+this.getDefaultAliasFieldKeyword()+alias;
  541.         this.fields.add(field);
  542.         this.fieldNames.add(alias);
  543.         this.fieldNameIsFunction.put(alias, false);
  544.         
  545.         return this;
  546.     }
  547.     




  552.     // SELECT FIELDS COUNTS

  554.     /**
  555.      * Aggiunge un field count alla select, con un alias, del campo <var>fieldCount</var>
  556.      * es: SELECT count(*) as alias FROM ....
  557.      * 
  558.      * @param alias Alias
  559.      */
  560.     @Override
  561.     public ISQLQueryObject addSelectCountField(String alias) throws SQLQueryObjectException{
  562.         String fieldSQL = "count(*)";
  563.         if(alias != null){
  564.             /**fieldSQL = fieldSQL + " as "+alias;*/
  565.             fieldSQL = fieldSQL + getDefaultAliasFieldKeyword() + alias;
  566.         }
  567.         this.engineAddSelectField(null,fieldSQL,null,false,true);
  568.         this.fieldNames.add(alias);
  569.         this.fieldNameIsFunction.put(alias, true);
  570.         return this;
  571.     }

  573.     /**
  574.      * Aggiunge un field count alla select, con un alias, del campo <var>fieldCount</var>
  575.      * es: SELECT count(fieldCount) as alias FROM ....
  576.      * 
  577.      * @param fieldCount Nome del Field
  578.      * @param alias Alias
  579.      */
  580.     @Override
  581.     public ISQLQueryObject addSelectCountField(String fieldCount,String alias) throws SQLQueryObjectException{
  582.         if(fieldCount==null)
  583.             fieldCount = "*";
  584.         String fieldSQL = "count("+fieldCount+")";
  585.         if(alias != null){
  586.             /**fieldSQL = fieldSQL + " as "+alias;*/
  587.             fieldSQL = fieldSQL + getDefaultAliasFieldKeyword() + alias;
  588.         }
  589.         this.engineAddSelectField(null,fieldSQL,null,false,true);
  590.         this.fieldNames.add(alias);
  591.         this.fieldNameIsFunction.put(alias, true);
  592.         return this;
  593.     }

  595.     /**
  596.      * Aggiunge un field count alla select, con un alias, del campo <var>fieldCount</var>
  597.      * es: SELECT count(DISTINCT fieldCount) as alias FROM ....
  598.      * 
  599.      * @param fieldCount Nome del Field
  600.      * @param alias Alias
  601.      */
  602.     @Override
  603.     public ISQLQueryObject addSelectCountField(String fieldCount,String alias,boolean distinct) throws SQLQueryObjectException{
  604.         if(fieldCount==null && distinct)
  605.             throw new SQLQueryObjectException("Non e' possibile utilizzare DISTINCT senza specificare un fieldCount");
  606.         if(distinct)
  607.             addSelectCountField("DISTINCT "+fieldCount,alias);
  608.         else
  609.             addSelectCountField(fieldCount,alias);
  610.         return this;
  611.     }

  613.     /**
  614.      * Aggiunge un field count alla select, con un alias, del campo <var>fieldCount</var>
  615.      * es: SELECT count(nomeTabella.fieldCount) as alias FROM ....
  616.      * 
  617.      * @param aliasTabella Nome della tabella su cui reperire il field
  618.      * @param fieldCount Alias del Field
  619.      * @param alias Alias
  620.      */
  621.     @Override
  622.     public ISQLQueryObject addSelectCountField(String aliasTabella,String fieldCount,String alias) throws SQLQueryObjectException{
  623.         if(!this.tableAlias.contains(aliasTabella)){
  624.             throw new SQLQueryObjectException(ALIAS_TABELLA_INDICATO_NON_ESISTE);
  625.         }
  626.         this.addSelectCountField(aliasTabella+"."+fieldCount, alias);
  627.         return this;
  628.     }

  630.     /**
  631.      * Aggiunge un field count alla select, con un alias, del campo <var>fieldCount</var>
  632.      * es: SELECT count(DISTINCT nomeTabella.fieldCount) as alias FROM ....
  633.      *
  634.      * @param aliasTabella Alias della tabella su cui reperire il field
  635.      * @param fieldCount Nome del Field
  636.      * @param alias Alias
  637.      */
  638.     @Override
  639.     public ISQLQueryObject addSelectCountField(String aliasTabella,String fieldCount,String alias,boolean distinct) throws SQLQueryObjectException{
  640.         if(!this.tableAlias.contains(aliasTabella)){
  641.             throw new SQLQueryObjectException(ALIAS_TABELLA_INDICATO_NON_ESISTE);
  642.         }
  643.         this.addSelectCountField(aliasTabella+"."+fieldCount, alias, distinct);
  644.         return this;
  645.     }





  651.     // SELECT FIELDS AVG

  653.     /**
  654.      * Aggiunge un field count alla select, con un alias, del campo <var>fieldAvg</var>
  655.      * es: SELECT count(fieldAvg) as alias FROM ....
  656.      * 
  657.      * @param field Nome del Field
  658.      * @param alias Alias
  659.      */
  660.     @Override
  661.     public ISQLQueryObject addSelectAvgField(String field,String alias) throws SQLQueryObjectException{
  662.         if(field==null)
  663.             throw new SQLQueryObjectException("field avg non puo' essere null");
  664.         engineAddSelectField(null, field, alias, true, "avg(",")",true);
  665.         return this;
  666.     }

  668.     /**
  669.      * Aggiunge un field count alla select, con un alias, del campo <var>fieldAvg</var>
  670.      * es: SELECT avg(nomeTabella.fieldAvg) as alias FROM ....
  671.      * 
  672.      * @param aliasTabella Alias della tabella su cui reperire il field
  673.      * @param field Nome del Field
  674.      * @param alias Alias
  675.      */
  676.     @Override
  677.     public ISQLQueryObject addSelectAvgField(String aliasTabella,String field,String alias) throws SQLQueryObjectException{
  678.         if(field==null)
  679.             throw new SQLQueryObjectException("field avg non puo' essere null");
  680.         if(aliasTabella==null)
  681.             throw new SQLQueryObjectException(NOME_TABELLA_DEVE_ESSERE_DIVERSO_NULL);
  682.         if(!this.tableAlias.contains(aliasTabella)){
  683.             throw new SQLQueryObjectException(ALIAS_TABELLA_INDICATO_NON_ESISTE);
  684.         }
  685.         engineAddSelectField(aliasTabella, field, alias, true, "avg(",")",true);
  686.         return this;
  687.     }

  689.     /**
  690.      * Aggiunge un field count alla select, con un alias, del campo <var>fieldAvg</var> (di tipo Timestamp)
  691.      * es: SELECT avg(fieldAvg) as alias FROM ....
  692.      * 
  693.      * @param field Nome del Field
  694.      * @param alias Alias
  695.      */
  696.     /**@Override
  697.     public abstract ISQLQueryObject addSelectAvgTimestampField(String field,String alias) throws SQLQueryObjectException;*/

  699.     /**
  700.      * Aggiunge un field count alla select, con un alias, del campo <var>fieldAvg</var> (di tipo Timestamp)
  701.      * es: SELECT avg(nomeTabella.fieldAvg) as alias FROM ....
  702.      *
  703.      * @param aliasTabella Alias della tabella su cui reperire il field
  704.      * @param field Nome del Field
  705.      * @param alias Alias
  706.      */
  707.     @Override
  708.     public ISQLQueryObject addSelectAvgTimestampField(String aliasTabella,String field,String alias) throws SQLQueryObjectException{
  709.         if(!this.tableAlias.contains(aliasTabella)){
  710.             throw new SQLQueryObjectException(ALIAS_TABELLA_INDICATO_NON_ESISTE);
  711.         }
  712.         addSelectAvgTimestampField(aliasTabella+"."+field, alias);
  713.         return this;
  714.     }







  722.     // SELECT FIELDS MAX

  724.     /**
  725.      * Aggiunge un field count alla select, con un alias, del campo <var>field</var> 
  726.      * es: SELECT max(field) as alias FROM ....
  727.      * 
  728.      * @param field Nome del Field
  729.      * @param alias Alias
  730.      */
  731.     @Override
  732.     public ISQLQueryObject addSelectMaxField(String field,String alias) throws SQLQueryObjectException{
  733.         if(field==null)
  734.             throw new SQLQueryObjectException(FIELD_DEVE_ESSERE_DIVERSO_NULL);
  735.         engineAddSelectField(null, field, alias, true, "max(",")",true);
  736.         return this;
  737.     }

  739.     /**
  740.      * Aggiunge un field count alla select, con un alias, del campo <var>field</var> 
  741.      * es: SELECT max(nomeTabella.field) as alias FROM ....
  742.      * 
  743.      * @param aliasTabella Alias della tabella su cui reperire il field
  744.      * @param field Nome del Field
  745.      * @param alias alias
  746.      */
  747.     @Override
  748.     public ISQLQueryObject addSelectMaxField(String aliasTabella,String field,String alias) throws SQLQueryObjectException{
  749.         if(field==null)
  750.             throw new SQLQueryObjectException(FIELD_DEVE_ESSERE_DIVERSO_NULL);
  751.         if(aliasTabella==null)
  752.             throw new SQLQueryObjectException(NOME_TABELLA_DEVE_ESSERE_DIVERSO_NULL);
  753.         if(!this.tableAlias.contains(aliasTabella)){
  754.             throw new SQLQueryObjectException(ALIAS_TABELLA_INDICATO_NON_ESISTE);
  755.         }
  756.         engineAddSelectField(aliasTabella, field, alias, true, "max(",")",true);
  757.         return this;
  758.     }

  760.     /**
  761.      * Aggiunge un field count alla select, con un alias, del campo <var>field</var> (di tipo Timestamp)
  762.      * es: SELECT max(field) as alias FROM ....
  763.      * 
  764.      * @param field Nome del Field
  765.      * @param alias Alias
  766.      */
  767.     /**@Override
  768.     public abstract ISQLQueryObject addSelectMaxTimestampField(String field,String alias) throws SQLQueryObjectException;*/

  770.     /**
  771.      * Aggiunge un field count alla select, con un alias, del campo <var>field</var> (di tipo Timestamp)
  772.      * es: SELECT max(nomeTabella.field) as alias FROM ....
  773.      * 
  774.      * @param aliasTabella alias della tabella su cui reperire il field
  775.      * @param field Nome del Field
  776.      * @param alias Alias
  777.      */
  778.     @Override
  779.     public ISQLQueryObject addSelectMaxTimestampField(String aliasTabella,String field,String alias) throws SQLQueryObjectException{
  780.         if(!this.tableAlias.contains(aliasTabella)){
  781.             throw new SQLQueryObjectException(ALIAS_TABELLA_INDICATO_NON_ESISTE);
  782.         }
  783.         addSelectMaxTimestampField(aliasTabella+"."+field, alias);
  784.         return this;
  785.     }











  797.     // SELECT FIELDS MIN

  799.     /**
  800.      * Aggiunge un field count alla select, con un alias, del campo <var>field</var>
  801.      * es: SELECT min(field) as alias FROM ....
  802.      * 
  803.      * @param field Nome del Field
  804.      * @param alias Alias
  805.      */
  806.     @Override
  807.     public ISQLQueryObject addSelectMinField(String field,String alias) throws SQLQueryObjectException{
  808.         if(field==null)
  809.             throw new SQLQueryObjectException(FIELD_DEVE_ESSERE_DIVERSO_NULL);
  810.         engineAddSelectField(null, field, alias, true, "min(",")",true);
  811.         return this;
  812.     }

  814.     /**
  815.      * Aggiunge un field count alla select, con un alias, del campo <var>field</var>
  816.      * es: SELECT min(nomeTabella.field) as alias FROM ....
  817.      * 
  818.      * @param aliasTabella Alias della tabella su cui reperire il field
  819.      * @param field Nome del Field
  820.      * @param alias
  821.      */
  822.     @Override
  823.     public ISQLQueryObject addSelectMinField(String aliasTabella,String field,String alias) throws SQLQueryObjectException{
  824.         if(field==null)
  825.             throw new SQLQueryObjectException(FIELD_DEVE_ESSERE_DIVERSO_NULL);
  826.         if(aliasTabella==null)
  827.             throw new SQLQueryObjectException(NOME_TABELLA_DEVE_ESSERE_DIVERSO_NULL);
  828.         if(!this.tableAlias.contains(aliasTabella)){
  829.             throw new SQLQueryObjectException(ALIAS_TABELLA_INDICATO_NON_ESISTE);
  830.         }
  831.         engineAddSelectField(aliasTabella, field, alias, true, "min(",")",true);
  832.         return this;
  833.     }

  835.     /**
  836.      * Aggiunge un field count alla select, con un alias, del campo <var>field</var> (di tipo Timestamp)
  837.      * es: SELECT min(field) as alias FROM ....
  838.      * 
  839.      * @param field Nome del Field
  840.      * @param alias
  841.      */
  842.     /**@Override
  843.     public abstract ISQLQueryObject addSelectMinTimestampField(String field,String alias) throws SQLQueryObjectException;*/

  845.     /**
  846.      * Aggiunge un field count alla select, con un alias, del campo <var>field</var> (di tipo Timestamp)
  847.      * es: SELECT min(nomeTabella.field) as alias FROM ....
  848.      * 
  849.      * @param aliasTabella Alias della tabella su cui reperire il field
  850.      * @param field Nome del Field
  851.      * @param alias
  852.      */
  853.     @Override
  854.     public ISQLQueryObject addSelectMinTimestampField(String aliasTabella,String field,String alias) throws SQLQueryObjectException{
  855.         if(!this.tableAlias.contains(aliasTabella)){
  856.             throw new SQLQueryObjectException(ALIAS_TABELLA_INDICATO_NON_ESISTE);
  857.         }
  858.         addSelectMinTimestampField(aliasTabella+"."+field, alias);
  859.         return this;
  860.     }










  871.     // SELECT FIELDS SUM

  873.     /**
  874.      * Aggiunge un field count alla select, con un alias, del campo <var>field</var>
  875.      * es: SELECT sum(field) as alias FROM ....
  876.      * 
  877.      * @param field Nome del Field
  878.      * @param alias Alias
  879.      */
  880.     @Override
  881.     public ISQLQueryObject addSelectSumField(String field,String alias) throws SQLQueryObjectException{
  882.         if(field==null)
  883.             throw new SQLQueryObjectException(FIELD_DEVE_ESSERE_DIVERSO_NULL);
  884.         engineAddSelectField(null, field, alias, true, "sum(",")",true);
  885.         return this;
  886.     }

  888.     /**
  889.      * Aggiunge un field count alla select, con un alias, del campo <var>field</var>
  890.      * es: SELECT sum(nomeTabella.field) as alias FROM ....
  891.      * 
  892.      * @param aliasTabella Alias della tabella su cui reperire il field
  893.      * @param field Nome del Field
  894.      * @param alias
  895.      */
  896.     @Override
  897.     public ISQLQueryObject addSelectSumField(String aliasTabella,String field,String alias) throws SQLQueryObjectException{
  898.         if(field==null)
  899.             throw new SQLQueryObjectException(FIELD_DEVE_ESSERE_DIVERSO_NULL);
  900.         if(aliasTabella==null)
  901.             throw new SQLQueryObjectException(NOME_TABELLA_DEVE_ESSERE_DIVERSO_NULL);
  902.         if(!this.tableAlias.contains(aliasTabella)){
  903.             throw new SQLQueryObjectException(ALIAS_TABELLA_INDICATO_NON_ESISTE);
  904.         }
  905.         engineAddSelectField(aliasTabella, field, alias, true, "sum(",")",true);
  906.         return this;
  907.     }

  909.     /**
  910.      * Aggiunge un field count alla select, con un alias, del campo <var>field</var> (di tipo Timestamp)
  911.      * es: SELECT sum(field) as alias FROM ....
  912.      * 
  913.      * @param field Nome del Field
  914.      * @param alias
  915.      */
  916.     /**@Override
  917.     public abstract ISQLQueryObject addSelectSumTimestampField(String field,String alias) throws SQLQueryObjectException;*/

  919.     /**
  920.      * Aggiunge un field count alla select, con un alias, del campo <var>field</var> (di tipo Timestamp)
  921.      * es: SELECT sum(nomeTabella.field) as alias FROM ....
  922.      * 
  923.      * @param aliasTabella Alias della tabella su cui reperire il field
  924.      * @param field Nome del Field
  925.      * @param alias
  926.      */
  927.     @Override
  928.     public ISQLQueryObject addSelectSumTimestampField(String aliasTabella,String field,String alias) throws SQLQueryObjectException{
  929.         if(!this.tableAlias.contains(aliasTabella)){
  930.             throw new SQLQueryObjectException(ALIAS_TABELLA_INDICATO_NON_ESISTE);
  931.         }
  932.         addSelectSumTimestampField(aliasTabella+"."+field, alias);
  933.         return this;
  934.     }

  936.     
  937.     
  938.     
  939.     
  940.     
  941.     // DATE TIME
  942.     
  943.     protected static final String DATE_PART_YEAR = "YEAR";
  944.     protected static final String DATE_PART_MONTH = "MONTH";
  945.     protected static final String DATE_PART_DAY = "DAY";
  946.     
  947.     protected static final String TIME_PART_HOUR = "HOUR";
  948.     protected static final String TIME_PART_MINUTE = "MINUTE";
  949.     protected static final String TIME_PART_SECOND = "SECOND";
  950.     
  951.     protected String getDateTimePart(DateTimePartEnum dateTimePart) throws SQLQueryObjectException {
  952.         switch (dateTimePart) {
  953.         case YEAR:
  954.             return DATE_PART_YEAR;
  955.         case MONTH:
  956.             return DATE_PART_MONTH;
  957.         case DAY:
  958.             return DATE_PART_DAY;
  959.         case HOUR:
  960.             return TIME_PART_HOUR;
  961.         case MINUTE:
  962.             return TIME_PART_MINUTE;
  963.         case SECOND:
  964.             return TIME_PART_SECOND;
  965.         }
  966.         throw new SQLQueryObjectException("DateTimePartEnum '"+dateTimePart+"' unknown");
  967.     }
  968.     public String getExtractDateTimePartFromTimestampFieldPrefix(DateTimePartEnum dateTimePart) throws SQLQueryObjectException {
  969.         if(dateTimePart==null) {
  970.             throw new SQLQueryObjectException("dateTimePart undefined");
  971.         }
  972.         String dateTimePartString = getDateTimePart(dateTimePart);
  973.         return "EXTRACT("+dateTimePartString+FROM_SEPARATOR; 
  974.     }
  975.     public String getExtractDateTimePartFromTimestampFieldSuffix(DateTimePartEnum dateTimePart) throws SQLQueryObjectException {
  976.         if(dateTimePart==null) {
  977.             throw new SQLQueryObjectException("dateTimePart undefined");
  978.         }
  979.         return ")"; 
  980.     }
  981.     
  982.     private ISQLQueryObject addSelectTimestampFieldEngine(String field,String alias, DateTimePartEnum dateTimePart) throws SQLQueryObjectException{
  983.         if(field==null)
  984.             throw new SQLQueryObjectException(FIELD_DEVE_ESSERE_DIVERSO_NULL); 
  985.         engineAddSelectField(null, field, alias, true, 
  986.                 getExtractDateTimePartFromTimestampFieldPrefix(dateTimePart),
  987.                 getExtractDateTimePartFromTimestampFieldSuffix(dateTimePart),
  988.                 true);
  989.         return this;
  990.     }
  991.     private ISQLQueryObject addSelectTimestampFieldEngine(String aliasTabella,String field,String alias, DateTimePartEnum dateTimePart) throws SQLQueryObjectException{
  992.         if(field==null)
  993.             throw new SQLQueryObjectException(FIELD_DEVE_ESSERE_DIVERSO_NULL);
  994.         if(aliasTabella==null)
  995.             throw new SQLQueryObjectException(NOME_TABELLA_DEVE_ESSERE_DIVERSO_NULL);
  996.         if(!this.tableAlias.contains(aliasTabella)){
  997.             throw new SQLQueryObjectException(ALIAS_TABELLA_INDICATO_NON_ESISTE);
  998.         }
  999.         engineAddSelectField(aliasTabella, field, alias, true, 
  1000.                 getExtractDateTimePartFromTimestampFieldPrefix(dateTimePart),
  1001.                 getExtractDateTimePartFromTimestampFieldSuffix(dateTimePart),
  1002.                 true);
  1003.         return this;
  1004.     }
  1005.     
  1006.     /**
  1007.      * Aggiunge un field alla select che si occupa di estrarre l'anno dal campo <var>field</var> (di tipo Timestamp)
  1008.      * es: SELECT EXTRACT(YEAR FROM field) as alias FROM ....
  1009.      * 
  1010.      * @param field Nome del Field
  1011.      * @param alias Alias
  1012.      */
  1013.     @Override
  1014.     public ISQLQueryObject addSelectYearTimestampField(String field,String alias) throws SQLQueryObjectException{
  1015.         return addSelectTimestampFieldEngine(field, alias, DateTimePartEnum.YEAR);
  1016.     }
  1017.     
  1018.     /**
  1019.      * Aggiunge un field alla select che si occupa di estrarre l'anno dal campo <var>field</var> (di tipo Timestamp)
  1020.      * es: SELECT EXTRACT(YEAR FROM nomeTabella.field) as alias FROM ....
  1021.      * 
  1022.      * @param aliasTabella Alias della tabella su cui reperire il field
  1023.      * @param field Nome del Field
  1024.      * @param alias Alias
  1025.      */
  1026.     @Override
  1027.     public ISQLQueryObject addSelectYearTimestampField(String aliasTabella,String field,String alias) throws SQLQueryObjectException{
  1028.         return addSelectTimestampFieldEngine(aliasTabella, field, alias, DateTimePartEnum.YEAR);
  1029.     }
  1030.     
  1031.     /**
  1032.      * Aggiunge un field alla select che si occupa di estrarre il mese dal campo <var>field</var> (di tipo Timestamp)
  1033.      * es: SELECT EXTRACT(MONTH FROM field) as alias FROM ....
  1034.      * 
  1035.      * @param field Nome del Field
  1036.      * @param alias Alias
  1037.      */
  1038.     @Override
  1039.     public ISQLQueryObject addSelectMonthTimestampField(String field,String alias) throws SQLQueryObjectException{
  1040.         return addSelectTimestampFieldEngine(field, alias, DateTimePartEnum.MONTH);
  1041.     }
  1042.     
  1043.     /**
  1044.      * Aggiunge un field alla select che si occupa di estrarre il mese dal campo <var>field</var> (di tipo Timestamp)
  1045.      * es: SELECT EXTRACT(MONTH FROM nomeTabella.field) as alias FROM ....
  1046.      * 
  1047.      * @param aliasTabella Alias della tabella su cui reperire il field
  1048.      * @param field Nome del Field
  1049.      * @param alias Alias
  1050.      */
  1051.     @Override
  1052.     public ISQLQueryObject addSelectMonthTimestampField(String aliasTabella,String field,String alias) throws SQLQueryObjectException{
  1053.         return addSelectTimestampFieldEngine(aliasTabella, field, alias, DateTimePartEnum.MONTH);
  1054.     }
  1055.     
  1056.     /**
  1057.      * Aggiunge un field alla select che si occupa di estrarre il giorno dal campo <var>field</var> (di tipo Timestamp)
  1058.      * es: SELECT EXTRACT(DAY FROM field) as alias FROM ....
  1059.      * 
  1060.      * @param field Nome del Field
  1061.      * @param alias Alias
  1062.      */
  1063.     @Override
  1064.     public ISQLQueryObject addSelectDayTimestampField(String field,String alias) throws SQLQueryObjectException{
  1065.         return addSelectTimestampFieldEngine(field, alias, DateTimePartEnum.DAY);
  1066.     }
  1067.     
  1068.     /**
  1069.      * Aggiunge un field alla select che si occupa di estrarre il giorno dal campo <var>field</var> (di tipo Timestamp)
  1070.      * es: SELECT EXTRACT(DAY FROM nomeTabella.field) as alias FROM ....
  1071.      * 
  1072.      * @param aliasTabella Alias della tabella su cui reperire il field
  1073.      * @param field Nome del Field
  1074.      * @param alias Alias
  1075.      */
  1076.     @Override
  1077.     public ISQLQueryObject addSelectDayTimestampField(String aliasTabella,String field,String alias) throws SQLQueryObjectException{
  1078.         return addSelectTimestampFieldEngine(aliasTabella, field, alias, DateTimePartEnum.DAY);
  1079.     }
  1080.     
  1081.     /**
  1082.      * Aggiunge un field alla select che si occupa di estrarre l'ora dal campo <var>field</var> (di tipo Timestamp)
  1083.      * es: SELECT EXTRACT(HOUR FROM field) as alias FROM ....
  1084.      * 
  1085.      * @param field Nome del Field
  1086.      * @param alias Alias
  1087.      */
  1088.     @Override
  1089.     public ISQLQueryObject addSelectHourTimestampField(String field,String alias) throws SQLQueryObjectException{
  1090.         return addSelectTimestampFieldEngine(field, alias, DateTimePartEnum.HOUR);
  1091.     }
  1092.     
  1093.     /**
  1094.      * Aggiunge un field alla select che si occupa di estrarre l'ora dal campo <var>field</var> (di tipo Timestamp)
  1095.      * es: SELECT EXTRACT(HOUR FROM nomeTabella.field) as alias FROM ....
  1096.      * 
  1097.      * @param aliasTabella Alias della tabella su cui reperire il field
  1098.      * @param field Nome del Field
  1099.      * @param alias Alias
  1100.      */
  1101.     @Override
  1102.     public ISQLQueryObject addSelectHourTimestampField(String aliasTabella,String field,String alias) throws SQLQueryObjectException{
  1103.         return addSelectTimestampFieldEngine(aliasTabella, field, alias, DateTimePartEnum.HOUR);
  1104.     }
  1105.     
  1106.     /**
  1107.      * Aggiunge un field alla select che si occupa di estrarre i minuti dal campo <var>field</var> (di tipo Timestamp)
  1108.      * es: SELECT EXTRACT(MINUTE FROM field) as alias FROM ....
  1109.      * 
  1110.      * @param field Nome del Field
  1111.      * @param alias Alias
  1112.      */
  1113.     @Override
  1114.     public ISQLQueryObject addSelectMinuteTimestampField(String field,String alias) throws SQLQueryObjectException{
  1115.         return addSelectTimestampFieldEngine(field, alias, DateTimePartEnum.MINUTE);
  1116.     }
  1117.     
  1118.     /**
  1119.      * Aggiunge un field alla select che si occupa di estrarre i minuti dal campo <var>field</var> (di tipo Timestamp)
  1120.      * es: SELECT EXTRACT(MINUTE FROM nomeTabella.field) as alias FROM ....
  1121.      * 
  1122.      * @param aliasTabella Alias della tabella su cui reperire il field
  1123.      * @param field Nome del Field
  1124.      * @param alias Alias
  1125.      */
  1126.     @Override
  1127.     public ISQLQueryObject addSelectMinuteTimestampField(String aliasTabella,String field,String alias) throws SQLQueryObjectException{
  1128.         return addSelectTimestampFieldEngine(aliasTabella, field, alias, DateTimePartEnum.MINUTE);
  1129.     }
  1130.     
  1131.     /**
  1132.      * Aggiunge un field alla select che si occupa di estrarre i secondi dal campo <var>field</var> (di tipo Timestamp)
  1133.      * es: SELECT EXTRACT(SECOND FROM field) as alias FROM ....
  1134.      * 
  1135.      * @param field Nome del Field
  1136.      * @param alias Alias
  1137.      */
  1138.     @Override
  1139.     public ISQLQueryObject addSelectSecondTimestampField(String field,String alias) throws SQLQueryObjectException{
  1140.         return addSelectTimestampFieldEngine(field, alias, DateTimePartEnum.SECOND);
  1141.     }
  1142.     
  1143.     /**
  1144.      * Aggiunge un field alla select che si occupa di estrarre i secondi dal campo <var>field</var> (di tipo Timestamp)
  1145.      * es: SELECT EXTRACT(SECOND FROM nomeTabella.field) as alias FROM ....
  1146.      * 
  1147.      * @param aliasTabella Alias della tabella su cui reperire il field
  1148.      * @param field Nome del Field
  1149.      * @param alias Alias
  1150.      */
  1151.     @Override
  1152.     public ISQLQueryObject addSelectSecondTimestampField(String aliasTabella,String field,String alias) throws SQLQueryObjectException{
  1153.         return addSelectTimestampFieldEngine(aliasTabella, field, alias, DateTimePartEnum.SECOND);
  1154.     }
  1155.     
  1156.     
  1157.     
  1158.     
  1159.     
  1160.     
  1161.     private static final String DAY_FORMAT_FULL_DAY_NAME = "DAY";
  1162.     private static final String DAY_FORMAT_SHORT_DAY_NAME = "DY";
  1163.     private static final String DAY_FORMAT_DAY_OF_YEAR = "DDD";
  1164.     private static final String DAY_FORMAT_DAY_OF_WEEK = "D";
  1165.     
  1166.     protected String getDayFormat(DayFormatEnum dayFormat) throws SQLQueryObjectException {
  1167.         switch (dayFormat) {
  1168.         case FULL_DAY_NAME:
  1169.             return DAY_FORMAT_FULL_DAY_NAME;
  1170.         case SHORT_DAY_NAME:
  1171.             return DAY_FORMAT_SHORT_DAY_NAME;
  1172.         case DAY_OF_YEAR:
  1173.             return DAY_FORMAT_DAY_OF_YEAR;
  1174.         case DAY_OF_WEEK:
  1175.             return DAY_FORMAT_DAY_OF_WEEK;
  1176.         }
  1177.         throw new SQLQueryObjectException("DayFormatEnum '"+dayFormat+"' unknown");
  1178.     }
  1179.     public String getExtractDayFormatFromTimestampFieldPrefix(DayFormatEnum dayFormat) throws SQLQueryObjectException {
  1180.         if(dayFormat==null) {
  1181.             throw new SQLQueryObjectException("dayFormat undefined");
  1182.         }
  1183.         return "TO_CHAR("; 
  1184.     }
  1185.     public String getExtractDayFormatFromTimestampFieldSuffix(DayFormatEnum dayFormat) throws SQLQueryObjectException {
  1186.         if(dayFormat==null) {
  1187.             throw new SQLQueryObjectException("dayFormat undefined");
  1188.         }
  1189.         String dayFormatString = getDayFormat(dayFormat);
  1190.         return ", '"+dayFormatString+"')"; 
  1191.     }
  1192.     
  1193.     private ISQLQueryObject addSelectTimestampFieldEngine(String field,String alias, DayFormatEnum dayFormatEnum) throws SQLQueryObjectException{
  1194.         if(field==null)
  1195.             throw new SQLQueryObjectException(FIELD_DEVE_ESSERE_DIVERSO_NULL); 
  1196.         engineAddSelectField(null, field, alias, true, 
  1197.                 getExtractDayFormatFromTimestampFieldPrefix(dayFormatEnum),
  1198.                 getExtractDayFormatFromTimestampFieldSuffix(dayFormatEnum),
  1199.                 true);
  1200.         return this;
  1201.     }
  1202.     private ISQLQueryObject addSelectTimestampFieldEngine(String aliasTabella,String field,String alias, DayFormatEnum dayFormatEnum) throws SQLQueryObjectException{
  1203.         if(field==null)
  1204.             throw new SQLQueryObjectException(FIELD_DEVE_ESSERE_DIVERSO_NULL);
  1205.         if(aliasTabella==null)
  1206.             throw new SQLQueryObjectException(NOME_TABELLA_DEVE_ESSERE_DIVERSO_NULL);
  1207.         if(!this.tableAlias.contains(aliasTabella)){
  1208.             throw new SQLQueryObjectException(ALIAS_TABELLA_INDICATO_NON_ESISTE);
  1209.         }
  1210.         engineAddSelectField(aliasTabella, field, alias, true, 
  1211.                 getExtractDayFormatFromTimestampFieldPrefix(dayFormatEnum),
  1212.                 getExtractDayFormatFromTimestampFieldSuffix(dayFormatEnum),
  1213.                 true);
  1214.         return this;
  1215.     }
  1216.     
  1217.     /**
  1218.      * Aggiunge un field alla select che si occupa di estrarre il giorno, dal campo <var>field</var> (di tipo Timestamp), visualizzandolo nella forma 'full day name'
  1219.      * es: TO_CHAR(field, 'DAY') AS alias FROM ....
  1220.      * 
  1221.      * @param field Nome del Field
  1222.      * @param alias Alias
  1223.      */
  1224.     @Override
  1225.     public ISQLQueryObject addSelectFullDayNameTimestampField(String field,String alias) throws SQLQueryObjectException{
  1226.         return addSelectTimestampFieldEngine(field, alias, DayFormatEnum.FULL_DAY_NAME);
  1227.     }
  1228.     
  1229.     /**
  1230.      * Aggiunge un field alla select che si occupa di estrarre il giorno, dal campo <var>field</var> (di tipo Timestamp), visualizzandolo nella forma 'full day name'
  1231.      * es: TO_CHAR(nomeTabella.field, 'DAY') AS alias FROM ....
  1232.      * 
  1233.      * @param aliasTabella Alias della tabella su cui reperire il field
  1234.      * @param field Nome del Field
  1235.      * @param alias Alias
  1236.      */
  1237.     @Override
  1238.     public ISQLQueryObject addSelectFullDayNameTimestampField(String aliasTabella,String field,String alias) throws SQLQueryObjectException{
  1239.         return addSelectTimestampFieldEngine(aliasTabella, field, alias, DayFormatEnum.FULL_DAY_NAME);
  1240.     }
  1241.     
  1242.     /**
  1243.      * Aggiunge un field alla select che si occupa di estrarre il giorno, dal campo <var>field</var> (di tipo Timestamp), visualizzandolo nella forma 'short day name'
  1244.      * es: TO_CHAR(field, 'DY') AS alias FROM ....
  1245.      * 
  1246.      * @param field Nome del Field
  1247.      * @param alias Alias
  1248.      */
  1249.     @Override
  1250.     public ISQLQueryObject addSelectShortDayNameTimestampField(String field,String alias) throws SQLQueryObjectException{
  1251.         return addSelectTimestampFieldEngine(field, alias, DayFormatEnum.SHORT_DAY_NAME);
  1252.     }
  1253.     
  1254.     /**
  1255.      * Aggiunge un field alla select che si occupa di estrarre il giorno, dal campo <var>field</var> (di tipo Timestamp), visualizzandolo nella forma 'short day name'
  1256.      * es: TO_CHAR(nomeTabella.field, 'DY') AS alias FROM ....
  1257.      * 
  1258.      * @param aliasTabella Alias della tabella su cui reperire il field
  1259.      * @param field Nome del Field
  1260.      * @param alias Alias
  1261.      */
  1262.     @Override
  1263.     public ISQLQueryObject addSelectShortDayNameTimestampField(String aliasTabella,String field,String alias) throws SQLQueryObjectException{
  1264.         return addSelectTimestampFieldEngine(aliasTabella, field, alias, DayFormatEnum.SHORT_DAY_NAME);
  1265.     }
  1266.     
  1267.     /**
  1268.      * Aggiunge un field alla select che si occupa di estrarre il giorno, dal campo <var>field</var> (di tipo Timestamp), visualizzandolo nella forma 'day of year'
  1269.      * es: TO_CHAR(field, 'DDD') AS alias FROM ....
  1270.      * 
  1271.      * @param field Nome del Field
  1272.      * @param alias Alias
  1273.      */
  1274.     @Override
  1275.     public ISQLQueryObject addSelectDayOfYearTimestampField(String field,String alias) throws SQLQueryObjectException{
  1276.         return addSelectTimestampFieldEngine(field, alias, DayFormatEnum.DAY_OF_YEAR);
  1277.     }
  1278.     
  1279.     /**
  1280.      * Aggiunge un field alla select che si occupa di estrarre il giorno, dal campo <var>field</var> (di tipo Timestamp), visualizzandolo nella forma 'day of year'
  1281.      * es: TO_CHAR(nomeTabella.field, 'DDD') AS alias FROM ....
  1282.      * 
  1283.      * @param aliasTabella Alias della tabella su cui reperire il field
  1284.      * @param field Nome del Field
  1285.      * @param alias Alias
  1286.      */
  1287.     @Override
  1288.     public ISQLQueryObject addSelectDayOfYearTimestampField(String aliasTabella,String field,String alias) throws SQLQueryObjectException{
  1289.         return addSelectTimestampFieldEngine(aliasTabella, field, alias, DayFormatEnum.DAY_OF_YEAR);
  1290.     }
  1291.     
  1292.     /**
  1293.      * Aggiunge un field alla select che si occupa di estrarre il giorno, dal campo <var>field</var> (di tipo Timestamp), visualizzandolo nella forma 'day of week'
  1294.      * es: TO_CHAR(field, 'D') AS alias FROM ....
  1295.      * 
  1296.      * @param field Nome del Field
  1297.      * @param alias Alias
  1298.      */
  1299.     @Override
  1300.     public ISQLQueryObject addSelectDayOfWeekTimestampField(String field,String alias) throws SQLQueryObjectException{
  1301.         return addSelectTimestampFieldEngine(field, alias, DayFormatEnum.DAY_OF_WEEK);
  1302.     }
  1303.     
  1304.     /**
  1305.      * Aggiunge un field alla select che si occupa di estrarre il giorno, dal campo <var>field</var> (di tipo Timestamp), visualizzandolo nella forma 'day of week'
  1306.      * es: TO_CHAR(nomeTabella.field, 'D') AS alias FROM ....
  1307.      * 
  1308.      * @param aliasTabella Alias della tabella su cui reperire il field
  1309.      * @param field Nome del Field
  1310.      * @param alias Alias
  1311.      */
  1312.     @Override
  1313.     public ISQLQueryObject addSelectDayOfWeekTimestampField(String aliasTabella,String field,String alias) throws SQLQueryObjectException{
  1314.         return addSelectTimestampFieldEngine(aliasTabella, field, alias, DayFormatEnum.DAY_OF_WEEK);
  1315.     }


  1318.     
  1319.     /**
  1320.      * Aggiunge una costante alla select di tipo 'timestamp'
  1321.      * es: timestamp 'costante' AS alias FROM ....
  1322.      * 
  1323.      * @param date Costante
  1324.      * @param alias Alias
  1325.      */
  1326.     @Override
  1327.     public ISQLQueryObject addSelectTimestampConstantField(Date date,String alias) throws SQLQueryObjectException{
  1328.         if(date==null)
  1329.             throw new SQLQueryObjectException("Date non puo' essere null");
  1330.         
  1331.         String constantValue = getSelectTimestampConstantField(date);
  1332.         return this.addSelectAliasField(constantValue, alias);          
  1333.     }
  1334.     
  1335.     






  1342.     // SELECT FORCE INDEX

  1344.     /**
  1345.      * Aggiunge l'istruzione SQL per forzare l'utilizzo dell'indice indicato nel parametro nella lettura della tabella indicata
  1346.      * es: SELECT '/*+ index(nomeTabella indexName) *'  FROM ....
  1347.      * 
  1348.      * @param nomeTabella Nome della tabella su cui forzare l'indice
  1349.      * @param indexName Nome dell'indice
  1350.      */
  1351.     @Override
  1352.     public ISQLQueryObject addSelectForceIndex(String nomeTabella,String indexName) throws SQLQueryObjectException{
  1353.         // per adesso implementato solamente per oracle
  1354.         return this;
  1355.     }







  1363.     // SET DISTINCTS IN CIMA ALLA SELECT

  1365.     /**
  1366.      * Aggiunge un field alla select, se non sono presenti field, viene utilizzato '*'
  1367.      * es: SELECT DISTINCT nomeField,nomeFiled2.... FROM ....
  1368.      * 
  1369.      * @param value Indicazione sul distinct
  1370.      */
  1371.     @Override
  1372.     public void setSelectDistinct(boolean value) throws SQLQueryObjectException{
  1373.         this.distinct = value;

  1375.     }
  1376.     public boolean isSelectDistinct() throws SQLQueryObjectException{
  1377.         if(this.distinct &&
  1378.             this.fields.isEmpty()){
  1379.             throw new SQLQueryObjectException("Per usare la select distinct devono essere indicati dei select field");
  1380.         }
  1381.         return this.distinct;
  1382.     }






  1389.     // FIELDS/TABLE NAME

  1391.     /**
  1392.      * Ritorna i nomi dei fields impostati (se e' stato utilizzato un alias ritorna il valore dell'alias)
  1393.      * 
  1394.      * @return i nomi dei fields impostati (se e' stato utilizzato un alias ritorna il valore dell'alias)
  1395.      * @throws SQLQueryObjectException
  1396.      */
  1397.     @Override
  1398.     public List<String> getFieldsName() throws SQLQueryObjectException{
  1399.         if(this.fieldNames==null || this.fieldNames.isEmpty()){
  1400.             throw new SQLQueryObjectException(NESSUN_FIELD_IMPOSTATO);
  1401.         }

  1403.         return this.fieldNames;
  1404.     }
  1405.     
  1406.     /**
  1407.      * Indicazione se e' il nome rappresenta una funzione
  1408.      * 
  1409.      * @return Indicazione se e' il nome rappresenta una funzione
  1410.      * @throws SQLQueryObjectException
  1411.      */
  1412.     @Override
  1413.     public Boolean isFieldNameForFunction(String fieldName) throws SQLQueryObjectException{
  1414.         if(this.fieldNames==null || this.fieldNames.isEmpty()){
  1415.             throw new SQLQueryObjectException(NESSUN_FIELD_IMPOSTATO);
  1416.         }
  1417.         if(!this.fieldNameIsFunction.containsKey(fieldName)){
  1418.             throw new SQLQueryObjectException("Field ["+fieldName+"] non presente (se durante la definizione del field e' stato usato un 'alias' utilizzarlo come parametro di questo metodo)");
  1419.         }
  1420.         return this.fieldNameIsFunction.get(fieldName);
  1421.     }

  1423.     /**
  1424.      * Ritorna i nomi dei fields impostati (se e' stato utilizzato un alias ritorna comunque il nome della colonna)
  1425.      * 
  1426.      * @return nomi dei fields impostati (se e' stato utilizzato un alias ritorna comunque il nome della colonna)
  1427.      * @throws SQLQueryObjectException
  1428.      */
  1429.     //@Override
  1430.     public List<String> getFields() throws SQLQueryObjectException{
  1431.         if(this.fields==null || this.fields.isEmpty()){
  1432.             throw new SQLQueryObjectException(NESSUN_FIELD_IMPOSTATO);
  1433.         }

  1435.         return this.fields;
  1436.     }

  1438.     /**
  1439.      * Ritorna i nomi delle tabelle impostate (se e' stato utilizzato un alias ritorna il valore dell'alias)
  1440.      * 
  1441.      * @return nomi delle tabelle impostate (se e' stato utilizzato un alias ritorna il valore dell'alias)
  1442.      * @throws SQLQueryObjectException
  1443.      */
  1444.     @Override
  1445.     public List<String> getTablesName() throws SQLQueryObjectException{
  1446.         if(this.tableNames==null || this.tableNames.isEmpty()){
  1447.             throw new SQLQueryObjectException("Nessuna tabella impostata");
  1448.         }

  1450.         return this.tableNames;
  1451.     }

  1453.     /**
  1454.      * Ritorna i nomi delle tabelle impostate (se e' stato utilizzato un alias ritorna comunque il nome della tabella)
  1455.      * 
  1456.      * @return nomi delle tabelle impostate (se e' stato utilizzato un alias ritorna comunque il nome della tabella)
  1457.      * @throws SQLQueryObjectException
  1458.      */
  1459.     //@Override
  1460.     public List<String> getTables() throws SQLQueryObjectException{
  1461.         if(this.tables==null || this.tables.isEmpty()){
  1462.             throw new SQLQueryObjectException("Nessuna tabella impostata");
  1463.         }

  1465.         return this.tables;
  1466.     }



  1470.     
  1471.     
  1472.     
  1473.     
  1474.     /// FIELDS UNIX FUNCTIONS
  1475.     
  1476.     /**
  1477.      * Ritorna la conversione in UnixTimestamp della Colonna
  1478.      * 
  1479.      * @param column colonna da convertire in UnixTimestamp
  1480.      * @return conversione in UnixTimestamp della Colonna
  1481.      */
  1482.     /**@Override
  1483.     public abstract String getUnixTimestampConversion(String column);*/
  1484.     
  1485.     /**
  1486.      * Ritorna l'intervallo in unixTimestamp tra le due colonne fornite
  1487.      * 
  1488.      * @param columnMax colonna con intervallo temporale maggiore
  1489.      * @param columnMin colonna con intervallo temporale minore
  1490.      * @return ritorna l'intervallo in unixTimestamp tra le due colonne fornite
  1491.      */
  1492.     /**@Override
  1493.     public abstract String getDiffUnixTimestamp(String columnMax,String columnMin);*/

  1495.     
  1496.     
  1497.     
  1498.     
  1499.     
  1500.     // FIELDS/TABLE ALIAS
  1501.     
  1502.     // GESTIONE ALIAS 'as'
  1503.     // Non tutti i database supportano l'alias 'as', ad esempio Oracle genera un errore se viene usato l'alias con le tabelle.
  1504.     /**
  1505.      * Ritorna l'alias di default utilizzabile per un field
  1506.      * 
  1507.      * @return Ritorna l'alias di default utilizzabile per un field
  1508.      */
  1509.     @Override
  1510.     public String getDefaultAliasFieldKeyword(){
  1511.         return this.getSupportedAliasesField().get(0);
  1512.     }

  1514.     /**
  1515.      * Ritorna l'alias di default utilizzabile per una tabella
  1516.      * 
  1517.      * @return Ritorna l'alias di default utilizzabile per una tabella
  1518.      */
  1519.     @Override
  1520.     public String getDefaultAliasTableKeyword(){
  1521.         return this.getSupportedAliasesTable().get(0);
  1522.     }

  1524.     /**
  1525.      * Ritorna gli aliases utilizzabili per un field
  1526.      * 
  1527.      * @return Ritorna gli aliases utilizzabili per un field
  1528.      */
  1529.     @Override
  1530.     public List<String> getSupportedAliasesField(){
  1531.         return getSupportedAliasesEngine();
  1532.     }
  1533.     
  1534.     /**
  1535.      * Ritorna gli aliases utilizzabili per una tabella
  1536.      * 
  1537.      * @return Ritorna gli aliases utilizzabili per una tabella
  1538.      */
  1539.     @Override
  1540.     public List<String> getSupportedAliasesTable(){
  1541.         return getSupportedAliasesEngine();
  1542.     }
  1543.     
  1544.     private List<String> getSupportedAliasesEngine(){
  1545.         List<String> lista = new ArrayList<>();
  1546.         lista.add(" as ");
  1547.         lista.add(" ");
  1548.         return lista;
  1549.     }
  1550.     



  1554.     
  1555.     
  1556.     

  1558.     // Engine

  1560.     /**
  1561.      * Aggiunge un field alla select, se non sono presenti field, viene utilizzato '*'
  1562.      * es: SELECT nomeTabella.nomeField FROM ....
  1563.      * 
  1564.      * @param nomeTabella Nome della tabella su cui reperire il field
  1565.      * @param nomeField Nome del Field
  1566.      */
  1567.     protected ISQLQueryObject engineAddSelectField(String nomeTabella,String nomeField,String alias,boolean addFieldName,boolean isFunction) throws SQLQueryObjectException{
  1568.         return engineAddSelectField(nomeTabella, nomeField, alias, addFieldName, null, null,isFunction);
  1569.     }
  1570.     protected ISQLQueryObject engineAddSelectField(String nomeTabella,String nomeField,String alias,boolean addFieldName,
  1571.             String functionPrefix,String functionSuffix,boolean isFunction) throws SQLQueryObjectException{
  1572.         if(nomeField==null || "".equals(nomeField))
  1573.             throw new SQLQueryObjectException("Field is null or empty string");
  1574.         
  1575.         checkEngineAddSelectField(nomeField, alias);
  1576.         
  1577.         if(nomeTabella!=null && (!"".equals(nomeTabella))){
  1578.             engineAddSelectField(nomeTabella, nomeField, alias,
  1579.                     functionPrefix, functionSuffix);
  1580.         }else{
  1581.             engineAddSelectField(nomeField, alias,
  1582.                     functionPrefix, functionSuffix);
  1583.         }
  1584.         if(addFieldName){
  1585.             if(alias!=null){
  1586.                 this.fieldNames.add(alias);
  1587.                 this.fieldNameIsFunction.put(alias, isFunction);
  1588.             }else{
  1589.                 this.fieldNames.add(nomeField);
  1590.                 this.fieldNameIsFunction.put(nomeField, isFunction);
  1591.             }
  1592.         }
  1593.         return this;
  1594.     }
  1595.     private void checkEngineAddSelectField(String nomeField,String alias) throws SQLQueryObjectException {
  1596.         if(alias!=null){
  1597.             if(this.fields.contains("*")){
  1598.                 throw new SQLQueryObjectException("Alias "+alias+" del field "+nomeField+" non utilizzabile tra i select fields. La presenza del select field '*' non permette di inserirne altri");
  1599.             }
  1600.             if(this.fieldNames.contains(alias))
  1601.                 throw new SQLQueryObjectAlreadyExistsException("Alias "+alias+" gia inserito tra i select fields");
  1602.         }else{
  1603.             if(!"*".equals(nomeField) &&
  1604.                 this.fields.contains("*")){
  1605.                 throw new SQLQueryObjectException("Field "+nomeField+" non utilizzabile tra i select fields. La presenza del select field '*' non permette di inserirne altri");
  1606.             }
  1607.             if(this.fields.contains(nomeField))
  1608.                 throw new SQLQueryObjectAlreadyExistsException("Field "+nomeField+" gia inserito tra i select fields");
  1609.         }
  1610.     }
  1611.     private void engineAddSelectField(String nomeTabella, String nomeField, String alias,
  1612.             String functionPrefix,String functionSuffix) throws SQLQueryObjectException {
  1613.         if(!this.tableNames.contains(nomeTabella))
  1614.             throw new SQLQueryObjectException(TABELLA_PREFIX+nomeTabella+" non esiste tra le tabelle su cui effettuare la ricerca (se nella addFromTable e' stato utilizzato l'alias per la tabella, utilizzarlo anche come parametro in questo metodo)");
  1615.         String nomeTabellaConField = nomeTabella+"."+nomeField;
  1616.         if(functionPrefix!=null){
  1617.             nomeTabellaConField = functionPrefix + nomeTabellaConField;
  1618.         }
  1619.         if(functionSuffix!=null){
  1620.             nomeTabellaConField = nomeTabellaConField  + functionSuffix ;
  1621.         }
  1622.         if(alias!=null){
  1623.             /**this.fields.add(nomeTabellaConField+" as "+alias);*/
  1624.             this.fields.add(nomeTabellaConField+this.getDefaultAliasFieldKeyword()+alias);
  1625.             this.alias.put(alias, nomeTabellaConField);
  1626.         }else{
  1627.             this.fields.add(nomeTabellaConField);
  1628.         }
  1629.     }
  1630.     private void engineAddSelectField(String nomeField, String alias,
  1631.             String functionPrefix,String functionSuffix) {
  1632.         String tmp = nomeField + "";
  1633.         if(functionPrefix!=null){
  1634.             tmp = functionPrefix + tmp;
  1635.         }
  1636.         if(functionSuffix!=null){
  1637.             tmp = tmp + functionSuffix ;
  1638.         }
  1639.         if(alias!=null){
  1640.             /**this.fields.add(tmp+" as "+alias);*/
  1641.             this.fields.add(tmp+this.getDefaultAliasFieldKeyword()+alias);
  1642.             this.alias.put(alias, tmp);
  1643.         }else{
  1644.             this.fields.add(tmp);
  1645.         }
  1646.     }






  1653.     // FROM

  1655.     /**
  1656.      * Aggiunge una tabella di ricerca del from
  1657.      * es: SELECT * from tabella as tabella
  1658.      * 
  1659.      * @param tabella
  1660.      */
  1661.     @Override
  1662.     public ISQLQueryObject addFromTable(String tabella) throws SQLQueryObjectException{
  1663.         if(tabella==null || "".equals(tabella))
  1664.             throw new SQLQueryObjectException("Tabella is null or empty string");
  1665.         if(this.tableNames.contains(tabella))
  1666.             throw new SQLQueryObjectAlreadyExistsException(TABELLA_PREFIX+tabella+" gia' esistente tra le tabella su cui effettuare la ricerca");
  1667.         this.tableNames.add(tabella);
  1668.         this.tables.add(tabella);
  1669.         return this;
  1670.     }

  1672.     /**
  1673.      * Aggiunge una tabella di ricerca del from
  1674.      * es: SELECT * from tabella as alias
  1675.      * 
  1676.      * @param tabella Tabella
  1677.      * @param alias Alias
  1678.      */
  1679.     @Override
  1680.     public ISQLQueryObject addFromTable(String tabella,String alias) throws SQLQueryObjectException{
  1681.         if(tabella==null || "".equals(tabella))
  1682.             throw new SQLQueryObjectException("Tabella is null or empty string");
  1683.         if(alias==null || "".equals(alias))
  1684.             throw new SQLQueryObjectException("Alias tabella is null or empty string");
  1685.         if(this.tableNames.contains(alias))
  1686.             throw new SQLQueryObjectAlreadyExistsException(TABELLA_PREFIX+tabella+" gia' esistente tra le tabella su cui effettuare la ricerca");
  1687.         this.tableNames.add(alias);
  1688.         /**this.tables.add(tabella+" as "+alias);*/
  1689.         this.tables.add(tabella+this.getDefaultAliasTableKeyword()+alias);
  1690.         this.tableAlias.add(alias);
  1691.         return this;
  1692.     }




  1697.     // WHERE

  1699.     /**
  1700.      * Aggiunge una condizione di ricerca (e associa un operatore logico, se le condizioni di ricerca sono piu' di una)
  1701.      * es: SELECT * from tabella WHERE (condition)
  1702.      * 
  1703.      * @param condition
  1704.      */
  1705.     @Override
  1706.     public ISQLQueryObject addWhereCondition(String condition) throws SQLQueryObjectException{
  1707.         if(condition==null || "".equals(condition))
  1708.             throw new SQLQueryObjectException("Where Condition is null or empty string");
  1709.         String buildCondition = "( "+condition+" )";
  1710.         if( (buildCondition.indexOf("?")==-1) && this.conditions.contains(buildCondition))
  1711.             throw new SQLQueryObjectException(WHERE_CONDITION_PREFIX+condition+GIA_ESISTENTE_TRA_CONDIZIONI_WHERE);
  1712.         this.conditions.add(buildCondition);
  1713.         return this;
  1714.     }
  1715.     /**
  1716.      * Aggiunge una condizione di ricerca (e associa un operatore logico, se le condizioni di ricerca sono piu' di una)
  1717.      * Imposta come operatore logico di una successiva condizione (se esiste) l'AND se true, l'OR se false
  1718.      * es: SELECT * from tabella WHERE ((condition1) andLogicOperator (condition2) etc.....)
  1719.      * 
  1720.      * @param andLogicOperator
  1721.      * @param conditions
  1722.      */
  1723.     @Override
  1724.     public ISQLQueryObject addWhereCondition(boolean andLogicOperator,String... conditions) throws SQLQueryObjectException{
  1725.         this.addWhereCondition(andLogicOperator, false, conditions);
  1726.         return this;
  1727.     }


  1730.     /**
  1731.      * Aggiunge una condizione di ricerca (e associa un operatore logico, se le condizioni di ricerca sono piu' di una)
  1732.      * Imposta come operatore logico di una successiva condizione (se esiste) l'AND se true, l'OR se false
  1733.      * es: SELECT * from tabella WHERE ( [NOT] ( (condition1) andLogicOperator (condition2) etc.....) )
  1734.      * Se il parametro not is true, aggiunge il not davanti alle condizioni
  1735.      * 
  1736.      * @param andLogicOperator
  1737.      * @param not
  1738.      * @param conditions
  1739.      */
  1740.     @Override
  1741.     public ISQLQueryObject addWhereCondition(boolean andLogicOperator,boolean not,String... conditions) throws SQLQueryObjectException{
  1742.         if(conditions==null || conditions.length<=0)
  1743.             throw new SQLQueryObjectException("Where Conditions non esistenti");
  1744.         StringBuilder buildCondition = new StringBuilder();

  1746.         if(not){
  1747.             buildCondition.append("( NOT ");
  1748.         }

  1750.         buildCondition.append("( ");
  1751.         addWhereCondition(buildCondition, andLogicOperator, conditions);
  1752.         buildCondition.append(" )");

  1754.         if(not){
  1755.             buildCondition.append(")");
  1756.         }

  1758.         if((buildCondition.indexOf("?")==-1) && this.conditions.contains(buildCondition.toString()))
  1759.             throw new SQLQueryObjectException(WHERE_CONDITION_PREFIX+buildCondition.toString()+GIA_ESISTENTE_TRA_CONDIZIONI_WHERE);
  1760.         this.conditions.add(buildCondition.toString());
  1761.         return this;
  1762.     }
  1763.     private void addWhereCondition(StringBuilder buildCondition, boolean andLogicOperator,String... conditions) throws SQLQueryObjectException {
  1764.         for(int i=0; i<conditions.length; i++){
  1765.             if(i>0){
  1766.                 if(andLogicOperator){
  1767.                     buildCondition.append(AND_SEPARATOR);
  1768.                 }else{
  1769.                     buildCondition.append(OR_SEPARATOR);
  1770.                 }
  1771.             }
  1772.             if(conditions[i]==null || "".equals(conditions[i]))
  1773.                 throw new SQLQueryObjectException("Where Condition["+i+"] is null or empty string");
  1774.             buildCondition.append("(");
  1775.             buildCondition.append(conditions[i]);
  1776.             buildCondition.append(")");
  1777.         }
  1778.     }


  1781.     /**
  1782.      * Aggiunge una condizione di ricerca (e associa un operatore logico, se le condizioni di ricerca sono piu' di una)
  1783.      * es: SELECT * from tabella WHERE (field is null)
  1784.      * 
  1785.      * @param field Field da verificare
  1786.      */
  1787.     @Override
  1788.     public ISQLQueryObject addWhereIsNullCondition(String field) throws SQLQueryObjectException{
  1789.         if(field==null || "".equals(field)){
  1790.             throw new SQLQueryObjectException(IS_NULL_CONDITION_DEVE_ESSERE_DIVERSO_NULL);
  1791.         }
  1792.         this.addWhereCondition(field+" is null");
  1793.         return this;
  1794.     }

  1796.     /**
  1797.      * Aggiunge una condizione di ricerca (e associa un operatore logico, se le condizioni di ricerca sono piu' di una)
  1798.      * es: SELECT * from tabella WHERE (field is not null)
  1799.      * 
  1800.      * @param field Field da verificare
  1801.      */
  1802.     @Override
  1803.     public ISQLQueryObject addWhereIsNotNullCondition(String field) throws SQLQueryObjectException{
  1804.         if(field==null || "".equals(field)){
  1805.             throw new SQLQueryObjectException(IS_NULL_CONDITION_DEVE_ESSERE_DIVERSO_NULL);
  1806.         }
  1807.         this.addWhereCondition(field+" is not null");
  1808.         return this;
  1809.     }
  1810.     
  1811.     /**
  1812.      * Aggiunge una condizione di ricerca (e associa un operatore logico, se le condizioni di ricerca sono piu' di una)
  1813.      * es: SELECT * from tabella WHERE (field = '')
  1814.      * 
  1815.      * @param field Field da verificare
  1816.      */
  1817.     @Override
  1818.     public ISQLQueryObject addWhereIsEmptyCondition(String field) throws SQLQueryObjectException{
  1819.         if(field==null || "".equals(field)){
  1820.             throw new SQLQueryObjectException(IS_NULL_CONDITION_DEVE_ESSERE_DIVERSO_NULL);
  1821.         }
  1822.         this.addWhereCondition(field+" = ''");
  1823.         return this;
  1824.     }
  1825.     
  1826.     /**
  1827.      * Aggiunge una condizione di ricerca (e associa un operatore logico, se le condizioni di ricerca sono piu' di una)
  1828.      * es: SELECT * from tabella WHERE (field &lt;&gt; '')
  1829.      * 
  1830.      * @param field Field da verificare
  1831.      */
  1832.     @Override
  1833.     public ISQLQueryObject addWhereIsNotEmptyCondition(String field) throws SQLQueryObjectException{
  1834.         if(field==null || "".equals(field)){
  1835.             throw new SQLQueryObjectException(IS_NULL_CONDITION_DEVE_ESSERE_DIVERSO_NULL);
  1836.         }
  1837.         this.addWhereCondition(field+" <> ''");
  1838.         return this;
  1839.     }


  1842.     /**
  1843.      * Aggiunge una condizione di ricerca in un insieme di valori
  1844.      * esempio concreto:    SELECT * from tabella WHERE id IN (a,b,c,d);
  1845.      * Se viene indicato stringValueType a true, ogni valore viene trattoto come stringa e nella sql prodotto viene aggiunto il carattere ' all'inizio e alla fine.
  1846.      * 
  1847.      * @param field Field su cui effettuare la select
  1848.      * @param valore insieme di valori su cui effettuare il controllo
  1849.      * @throws SQLQueryObjectException
  1850.      */
  1851.     @Override
  1852.     public ISQLQueryObject addWhereINCondition(String field,boolean stringValueType,String ... valore) throws SQLQueryObjectException{
  1853.         if(valore==null || valore.length<1){
  1854.             throw new SQLQueryObjectException("Deve essere fornito almeno un valore");
  1855.         }
  1856.         StringBuilder bf = new StringBuilder(field);
  1857.         bf.append(" IN ( ");
  1858.         for (int i = 0; i < valore.length; i++) {
  1859.             if(i>0){
  1860.                 bf.append(",");
  1861.             }
  1862.             if(stringValueType){
  1863.                 bf.append("'");
  1864.                 bf.append(escapeStringValue(valore[i]));
  1865.                 bf.append("'");
  1866.             }
  1867.             else{
  1868.                 bf.append(valore[i]);
  1869.             }
  1870.         }
  1871.         bf.append(")");
  1872.         this.addWhereCondition(bf.toString());
  1873.         return this;
  1874.     }

  1876.     /**
  1877.      * Aggiunge una condizione di ricerca tra due valori
  1878.      * esempio concreto:    SELECT * from tabella WHERE id BEETWEEN a AND b
  1879.      * Se viene indicato stringValueType a true, ogni valore viene trattato come stringa e nella sql prodotto viene aggiunto il carattere ' all'inizio e alla fine.
  1880.      * 
  1881.      * @param field Field su cui effettuare la select
  1882.      * @param stringValueType indica se i valori devono essere trattati come stringhe o meno
  1883.      * @param leftValue Valore dell'intervallo sinistro
  1884.      * @param rightValue Valore dell'intervallo destro
  1885.      * @return SQLQueryObjectException
  1886.      * @throws SQLQueryObjectException
  1887.      */
  1888.     @Override
  1889.     public ISQLQueryObject addWhereBetweenCondition(String field,boolean stringValueType,String leftValue,String rightValue) throws SQLQueryObjectException{
  1890.         if(leftValue==null){
  1891.             throw new SQLQueryObjectException("Deve essere fornito un valore per l'intervallo sinistro");
  1892.         }
  1893.         if(rightValue==null){
  1894.             throw new SQLQueryObjectException("Deve essere fornito un valore per l'intervallo destro");
  1895.         }
  1896.         StringBuilder bf = new StringBuilder(field);
  1897.         bf.append(" BETWEEN ");
  1898.         if(stringValueType){
  1899.             bf.append("'");
  1900.             bf.append(escapeStringValue(leftValue));
  1901.             bf.append("'");
  1902.         }
  1903.         else{
  1904.             bf.append(leftValue);
  1905.         }
  1906.         bf.append(AND_SEPARATOR);
  1907.         if(stringValueType){
  1908.             bf.append("'");
  1909.             bf.append(escapeStringValue(rightValue));
  1910.             bf.append("'");
  1911.         }
  1912.         else{
  1913.             bf.append(rightValue);
  1914.         }
  1915.         this.addWhereCondition(bf.toString());
  1916.         return this;
  1917.     }

  1919.     private String createWhereLikeCondition(String columnName,String searchPattern,boolean escape) throws SQLQueryObjectException{
  1920.         if(columnName==null || "".equals(columnName))
  1921.             throw new SQLQueryObjectException("Where Condition column name is null or empty string");
  1922.         if(searchPattern==null || "".equals(searchPattern))
  1923.             throw new SQLQueryObjectException("Where Condition searchPattern is null or empty string");
  1924.         if(searchPattern.length()>1){
  1925.             if(searchPattern.startsWith("'"))
  1926.                 searchPattern = searchPattern.substring(1);
  1927.             if(searchPattern.endsWith("'"))
  1928.                 searchPattern = searchPattern.substring(0,searchPattern.length()-1);
  1929.         }
  1930.         String buildCondition = null;
  1931.         if(escape){
  1932.             EscapeSQLPattern escapePattern = escapePatternValue(searchPattern);
  1933.             String escapeClausole = "";
  1934.             if(escapePattern.isUseEscapeClausole()){
  1935.                 escapeClausole = ESCAPE_SEPARATOR+"'"+escapePattern.getEscapeClausole()+"'";
  1936.             }
  1937.             buildCondition = "( "+columnName+LIKE_SEPARATOR+"'"+escapePattern.getEscapeValue()+"'"+escapeClausole+" )";
  1938.         }
  1939.         else{
  1940.             buildCondition = "( "+columnName+LIKE_SEPARATOR+"'"+searchPattern+"' )";
  1941.         }
  1942.         return buildCondition;
  1943.     }

  1945.     /**
  1946.      * Aggiunge una condizione di ricerca
  1947.      * es: SELECT * from tabella WHERE (columnName LIKE 'searc"+LIKE_SEPARATOR+"rn')
  1948.      * 
  1949.      * @param columnName
  1950.      * @param searchPattern
  1951.      */
  1952.     @Override
  1953.     public ISQLQueryObject addWhereLikeCondition(String columnName,String searchPattern) throws SQLQueryObjectException{
  1954.         return addWhereLikeCondition(columnName, searchPattern,true);
  1955.     }
  1956.     @Override
  1957.     public ISQLQueryObject addWhereLikeCondition(String columnName,String searchPattern,boolean escape) throws SQLQueryObjectException{

  1959.         String buildCondition = this.createWhereLikeCondition(columnName, searchPattern,escape);
  1960.         if((buildCondition.indexOf("?")==-1) && this.conditions.contains(buildCondition))
  1961.             throw new SQLQueryObjectException(WHERE_CONDITION_PREFIX+buildCondition+GIA_ESISTENTE_TRA_CONDIZIONI_WHERE);
  1962.         this.conditions.add(buildCondition);
  1963.         return this;
  1964.     }

  1966.     /**
  1967.      * Ritorna una condizione di ricerca
  1968.      * es: "columnName LIKE 'searchPattern'"
  1969.      * 
  1970.      * @param columnName
  1971.      * @param searchPattern
  1972.      */
  1973.     @Override
  1974.     public String getWhereLikeCondition(String columnName,String searchPattern) throws SQLQueryObjectException{
  1975.         return this.createWhereLikeCondition(columnName, searchPattern,true);
  1976.     }
  1977.     @Override
  1978.     public String getWhereLikeCondition(String columnName,String searchPattern,boolean escape) throws SQLQueryObjectException{
  1979.         return this.createWhereLikeCondition(columnName, searchPattern,escape);
  1980.     }

  1982.     @Override
  1983.     public String getWhereLikeCondition(String columnName,String searchPattern, LikeConfig c) throws SQLQueryObjectException{
  1984.         return this.createWhereLikeCondition(columnName,searchPattern,
  1985.                 c.isEscape(),
  1986.                 c.isContains(), c.isStartsWith(), c.isEndsWith(),
  1987.                 c.isCaseInsensitive());
  1988.     }
  1989.     
  1990.     private String createWhereLikeCondition(String columnName,String searchPattern,
  1991.             boolean escape, 
  1992.             boolean contains, boolean startsWith, boolean endsWith,  
  1993.             boolean caseInsensitive) throws SQLQueryObjectException{
  1994.         if(columnName==null || "".equals(columnName))
  1995.             throw new SQLQueryObjectException("Where Condition column name is null or empty string");
  1996.         if(searchPattern==null || "".equals(searchPattern))
  1997.             throw new SQLQueryObjectException("Where Condition searchPattern is null or empty string");
  1998.         if(searchPattern.length()>1){
  1999.             if(searchPattern.startsWith("'"))
  2000.                 searchPattern = searchPattern.substring(1);
  2001.             if(searchPattern.endsWith("'"))
  2002.                 searchPattern = searchPattern.substring(0,searchPattern.length()-1);
  2003.         }
  2004.         String buildCondition = null;
  2005.         if(escape){
  2006.             buildCondition = createWhereLikeConditionEscapeEngine(columnName, searchPattern,
  2007.                     contains, startsWith, endsWith,  
  2008.                     caseInsensitive);
  2009.         }
  2010.         else{
  2011.             buildCondition = createWhereLikeConditionNoEscapeEngine(columnName, searchPattern,
  2012.                     contains, startsWith, endsWith,  
  2013.                     caseInsensitive);
  2014.         }

  2016.         return buildCondition;
  2017.     }
  2018.     private String createWhereLikeConditionEscapeEngine(String columnName,String searchPattern,
  2019.             boolean contains, boolean startsWith, boolean endsWith,  
  2020.             boolean caseInsensitive) throws SQLQueryObjectException {
  2021.         String buildCondition = null;
  2022.         if(caseInsensitive) {
  2023.             buildCondition = createWhereLikeConditionEscapeEngineCaseInsensitive(columnName, searchPattern,
  2024.                     contains, startsWith, endsWith);
  2025.         }
  2026.         else {
  2027.             buildCondition = createWhereLikeConditionEscapeEngineCaseSensitive(columnName, searchPattern,
  2028.                     contains, startsWith, endsWith);
  2029.         }
  2030.         return buildCondition;
  2031.     }
  2032.     private String createWhereLikeConditionEscapeEngineCaseInsensitive(String columnName,String searchPattern,
  2033.             boolean contains, boolean startsWith, boolean endsWith) throws SQLQueryObjectException {
  2034.         String buildCondition = null;
  2035.         EscapeSQLPattern escapePattern = escapePatternValue(searchPattern);
  2036.         String escapeClausole = "";
  2037.         if(escapePattern.isUseEscapeClausole()){
  2038.             escapeClausole = ESCAPE_SEPARATOR+"'"+escapePattern.getEscapeClausole()+"'";
  2039.         }
  2040.         if(contains) {
  2041.             buildCondition =LOWER_PREFIX+columnName+")"+LIKE_SEPARATOR+"'%"+escapePattern.getEscapeValue().toLowerCase()+"%'"+escapeClausole+" )";
  2042.         }
  2043.         else if(startsWith) {
  2044.             buildCondition =LOWER_PREFIX+columnName+")"+LIKE_SEPARATOR+"'"+escapePattern.getEscapeValue().toLowerCase()+"%'"+escapeClausole+" )";
  2045.         }
  2046.         else if(endsWith) {
  2047.             buildCondition =LOWER_PREFIX+columnName+")"+LIKE_SEPARATOR+"'%"+escapePattern.getEscapeValue().toLowerCase()+"'"+escapeClausole+" )";
  2048.         }
  2049.         else {
  2050.             buildCondition =LOWER_PREFIX+columnName+")"+LIKE_SEPARATOR+"'"+escapePattern.getEscapeValue().toLowerCase()+"'"+escapeClausole+" )";
  2051.         }   
  2052.         return buildCondition;
  2053.     }
  2054.     private String createWhereLikeConditionEscapeEngineCaseSensitive(String columnName,String searchPattern,
  2055.             boolean contains, boolean startsWith, boolean endsWith) throws SQLQueryObjectException {
  2056.         String buildCondition = null;
  2057.         EscapeSQLPattern escapePattern = escapePatternValue(searchPattern);
  2058.         String escapeClausole = "";
  2059.         if(escapePattern.isUseEscapeClausole()){
  2060.             escapeClausole = ESCAPE_SEPARATOR+"'"+escapePattern.getEscapeClausole()+"'";
  2061.         }
  2062.         if(contains) {
  2063.             buildCondition ="( "+columnName+LIKE_SEPARATOR+"'%"+escapePattern.getEscapeValue()+"%'"+escapeClausole+" )";
  2064.         }
  2065.         else if(startsWith) {
  2066.             buildCondition ="( "+columnName+LIKE_SEPARATOR+"'"+escapePattern.getEscapeValue()+"%'"+escapeClausole+" )";
  2067.         }
  2068.         else if(endsWith) {
  2069.             buildCondition ="( "+columnName+LIKE_SEPARATOR+"'%"+escapePattern.getEscapeValue()+"'"+escapeClausole+" )";
  2070.         }
  2071.         else {
  2072.             buildCondition ="( "+columnName+LIKE_SEPARATOR+"'"+escapePattern.getEscapeValue()+"'"+escapeClausole+" )";
  2073.         }   
  2074.         return buildCondition;
  2075.     }
  2076.     private String createWhereLikeConditionNoEscapeEngine(String columnName,String searchPattern,
  2077.             boolean contains, boolean startsWith, boolean endsWith,  
  2078.             boolean caseInsensitive) {
  2079.         String buildCondition = null;
  2080.         if(caseInsensitive) {
  2081.             buildCondition = createWhereLikeConditionNoEscapeEngineCaseInsensitive(columnName, searchPattern,
  2082.                     contains, startsWith, endsWith);
  2083.         }
  2084.         else {
  2085.             buildCondition = createWhereLikeConditionNoEscapeEngineCaseSensitive(columnName, searchPattern,
  2086.                     contains, startsWith, endsWith);
  2087.         }               
  2088.         return buildCondition;
  2089.     }
  2090.     private String createWhereLikeConditionNoEscapeEngineCaseInsensitive(String columnName,String searchPattern,
  2091.             boolean contains, boolean startsWith, boolean endsWith) {
  2092.         String buildCondition = null;
  2093.         if(contains) {
  2094.             buildCondition =LOWER_PREFIX+columnName+")"+LIKE_SEPARATOR+"'%"+searchPattern.toLowerCase()+"%' )";
  2095.         }
  2096.         else if(startsWith) {
  2097.             buildCondition =LOWER_PREFIX+columnName+")"+LIKE_SEPARATOR+"'"+searchPattern.toLowerCase()+"%' )";
  2098.         }
  2099.         else if(endsWith) {
  2100.             buildCondition =LOWER_PREFIX+columnName+")"+LIKE_SEPARATOR+"'%"+searchPattern.toLowerCase()+"' )";
  2101.         }
  2102.         else {
  2103.             buildCondition =LOWER_PREFIX+columnName+")"+LIKE_SEPARATOR+"'"+searchPattern.toLowerCase()+"' )";
  2104.         }               
  2105.         return buildCondition;
  2106.     }
  2107.     private String createWhereLikeConditionNoEscapeEngineCaseSensitive(String columnName,String searchPattern,
  2108.             boolean contains, boolean startsWith, boolean endsWith) {
  2109.         String buildCondition = null;
  2110.         if(contains) {
  2111.             buildCondition ="( "+columnName+LIKE_SEPARATOR+"'%"+searchPattern+"%' )";
  2112.         }
  2113.         else if(startsWith) {
  2114.             buildCondition ="( "+columnName+LIKE_SEPARATOR+"'"+searchPattern+"%' )";
  2115.         }
  2116.         else if(endsWith) {
  2117.             buildCondition ="( "+columnName+LIKE_SEPARATOR+"'%"+searchPattern+"' )";
  2118.         }
  2119.         else {
  2120.             buildCondition ="( "+columnName+LIKE_SEPARATOR+"'"+searchPattern+"' )";
  2121.         }               
  2122.         return buildCondition;
  2123.     }
  2124.     
  2125.     /**
  2126.      * Aggiunge una condizione di ricerca
  2127.      * es: SELECT * from tabella WHERE (columnName LIKE 'searchPattern')
  2128.      * 
  2129.      * @param columnName
  2130.      * @param searchPattern
  2131.      * @param contains true se la parola deve essere contenuta nella colonna, false se deve essere esattamente la colonna
  2132.      * @param caseInsensitive
  2133.      */
  2134.     @Override
  2135.     public ISQLQueryObject addWhereLikeCondition(String columnName,String searchPattern, boolean contains, boolean caseInsensitive) throws SQLQueryObjectException{
  2136.         return addWhereLikeCondition(columnName,searchPattern,true,contains,caseInsensitive);
  2137.     }
  2138.     @Override
  2139.     public ISQLQueryObject addWhereLikeCondition(String columnName,String searchPattern, boolean escape, boolean contains, boolean caseInsensitive) throws SQLQueryObjectException{

  2141.         String buildCondition = this.createWhereLikeCondition(columnName, searchPattern, 
  2142.                 escape, 
  2143.                 contains, false, false, 
  2144.                 caseInsensitive);
  2145.         if((buildCondition.indexOf("?")==-1) && this.conditions.contains(buildCondition))
  2146.             throw new SQLQueryObjectException(WHERE_CONDITION_PREFIX+buildCondition+GIA_ESISTENTE_TRA_CONDIZIONI_WHERE);
  2147.         this.conditions.add(buildCondition);
  2148.         return this;
  2149.     }

  2151.     @Override
  2152.     public ISQLQueryObject addWhereLikeCondition(String columnName,String searchPattern, LikeConfig likeConfig) throws SQLQueryObjectException{
  2153.         
  2154.         String buildCondition = this.createWhereLikeCondition(columnName, searchPattern, 
  2155.                 likeConfig.isEscape(), 
  2156.                 likeConfig.isContains(), likeConfig.isStartsWith(), likeConfig.isEndsWith(), 
  2157.                 likeConfig.isCaseInsensitive());
  2158.         if((buildCondition.indexOf("?")==-1) && this.conditions.contains(buildCondition))
  2159.             throw new SQLQueryObjectException(WHERE_CONDITION_PREFIX+buildCondition+GIA_ESISTENTE_TRA_CONDIZIONI_WHERE);
  2160.         this.conditions.add(buildCondition);
  2161.         return this;
  2162.         
  2163.     }
  2164.     
  2165.     /**
  2166.      * Ritorna una condizione di ricerca
  2167.      * es: "columnName LIKE 'searchPattern'"
  2168.      * 
  2169.      * @param columnName
  2170.      * @param searchPattern
  2171.      * @param contains true se la parola deve essere contenuta nella colonna, false se deve essere esattamente la colonna
  2172.      * @param caseInsensitive
  2173.      */
  2174.     @Override
  2175.     public String getWhereLikeCondition(String columnName,String searchPattern, boolean contains, boolean caseInsensitive) throws SQLQueryObjectException{
  2176.         return this.createWhereLikeCondition(columnName, searchPattern, 
  2177.                 true, 
  2178.                 contains, false, false,
  2179.                 caseInsensitive);
  2180.     }
  2181.     @Override
  2182.     public String getWhereLikeCondition(String columnName,String searchPattern,boolean escape, boolean contains, boolean caseInsensitive) throws SQLQueryObjectException{
  2183.         return this.createWhereLikeCondition(columnName, searchPattern, 
  2184.                 escape, 
  2185.                 contains, false, false,
  2186.                 caseInsensitive);
  2187.     }

  2189.     
  2190.     
  2191.     
  2192.     private ISQLQueryObject addWhereCondition(String columnName,String searchPattern, DateTimePartEnum dateTimePart) throws SQLQueryObjectException{
  2193.         if(columnName==null || "".equals(columnName)){
  2194.             throw new SQLQueryObjectException(FIELD_DEVE_ESSERE_DIVERSO_NULL);
  2195.         }
  2196.         String field = this.getExtractDateTimePartFromTimestampFieldPrefix(dateTimePart)+columnName+this.getExtractDateTimePartFromTimestampFieldSuffix(dateTimePart);
  2197.         this.addWhereCondition(field+" = '"+searchPattern+"'");
  2198.         return this;
  2199.     }

  2201.     /**
  2202.      * Aggiunge una condizione di ricerca
  2203.      * es: SELECT * from tabella WHERE (EXTRACT(YEAR FROM columnName) = 'pattern')
  2204.      * 
  2205.      * @param columnName
  2206.      * @param searchPattern
  2207.      */
  2208.     @Override
  2209.     public ISQLQueryObject addWhereYearCondition(String columnName,String searchPattern) throws SQLQueryObjectException{
  2210.         return addWhereCondition(columnName, searchPattern, DateTimePartEnum.YEAR);
  2211.     }
  2212.     
  2213.     /**
  2214.      * Aggiunge una condizione di ricerca
  2215.      * es: SELECT * from tabella WHERE (EXTRACT(MONTH FROM columnName) = 'pattern')
  2216.      * 
  2217.      * @param columnName
  2218.      * @param searchPattern
  2219.      */
  2220.     @Override
  2221.     public ISQLQueryObject addWhereMonthCondition(String columnName,String searchPattern) throws SQLQueryObjectException{
  2222.         return addWhereCondition(columnName, searchPattern, DateTimePartEnum.MONTH);
  2223.     }
  2224.     
  2225.     /**
  2226.      * Aggiunge una condizione di ricerca
  2227.      * es: SELECT * from tabella WHERE (EXTRACT(DAY FROM columnName) = 'pattern')
  2228.      * 
  2229.      * @param columnName
  2230.      * @param searchPattern
  2231.      */
  2232.     @Override
  2233.     public ISQLQueryObject addWhereDayCondition(String columnName,String searchPattern) throws SQLQueryObjectException{
  2234.         return addWhereCondition(columnName, searchPattern, DateTimePartEnum.DAY);
  2235.     }
  2236.     
  2237.     /**
  2238.      * Aggiunge una condizione di ricerca
  2239.      * es: SELECT * from tabella WHERE (EXTRACT(HOUR FROM columnName) = 'pattern')
  2240.      * 
  2241.      * @param columnName
  2242.      * @param searchPattern
  2243.      */
  2244.     @Override
  2245.     public ISQLQueryObject addWhereHourCondition(String columnName,String searchPattern) throws SQLQueryObjectException{
  2246.         return addWhereCondition(columnName, searchPattern, DateTimePartEnum.HOUR);
  2247.     }
  2248.     
  2249.     /**
  2250.      * Aggiunge una condizione di ricerca
  2251.      * es: SELECT * from tabella WHERE (EXTRACT(MINUTE FROM columnName) = 'pattern')
  2252.      * 
  2253.      * @param columnName
  2254.      * @param searchPattern
  2255.      */
  2256.     @Override
  2257.     public ISQLQueryObject addWhereMinuteCondition(String columnName,String searchPattern) throws SQLQueryObjectException{
  2258.         return addWhereCondition(columnName, searchPattern, DateTimePartEnum.MINUTE);
  2259.     }
  2260.     
  2261.     /**
  2262.      * Aggiunge una condizione di ricerca
  2263.      * es: SELECT * from tabella WHERE (EXTRACT(SECOND FROM columnName) = 'pattern')
  2264.      * 
  2265.      * @param columnName
  2266.      * @param searchPattern
  2267.      */
  2268.     @Override
  2269.     public ISQLQueryObject addWhereSecondCondition(String columnName,String searchPattern) throws SQLQueryObjectException{
  2270.         return addWhereCondition(columnName, searchPattern, DateTimePartEnum.SECOND);
  2271.     }
  2272.     
  2273.     
  2274.     
  2275.     private ISQLQueryObject addWhereCondition(String columnName,String searchPattern, DayFormatEnum dayFormatEnum) throws SQLQueryObjectException{
  2276.         if(columnName==null || "".equals(columnName)){
  2277.             throw new SQLQueryObjectException(FIELD_DEVE_ESSERE_DIVERSO_NULL);
  2278.         }
  2279.         String field = this.getExtractDayFormatFromTimestampFieldPrefix(dayFormatEnum)+columnName+this.getExtractDayFormatFromTimestampFieldSuffix(dayFormatEnum);
  2280.         this.addWhereCondition(field+" = '"+searchPattern+"'");
  2281.         return this;
  2282.     }
  2283.     
  2284.     /**
  2285.      * Aggiunge una condizione di ricerca
  2286.      * es: SELECT * from tabella WHERE (TO_CHAR(field, 'DAY') = 'pattern')
  2287.      * 
  2288.      * @param columnName
  2289.      * @param searchPattern
  2290.      */
  2291.     @Override
  2292.     public ISQLQueryObject addWhereFullDayNameCondition(String columnName,String searchPattern) throws SQLQueryObjectException{
  2293.         return addWhereCondition(columnName, searchPattern, DayFormatEnum.FULL_DAY_NAME);
  2294.     }
  2295.     
  2296.     /**
  2297.      * Aggiunge una condizione di ricerca
  2298.      * es: SELECT * from tabella WHERE (TO_CHAR(field, 'DY') = 'pattern')
  2299.      * 
  2300.      * @param columnName
  2301.      * @param searchPattern
  2302.      */
  2303.     @Override
  2304.     public ISQLQueryObject addWhereShortDayNameCondition(String columnName,String searchPattern) throws SQLQueryObjectException{
  2305.         return addWhereCondition(columnName, searchPattern, DayFormatEnum.SHORT_DAY_NAME);
  2306.     }
  2307.     
  2308.     /**
  2309.      * Aggiunge una condizione di ricerca
  2310.      * es: SELECT * from tabella WHERE (TO_CHAR(field, 'DDD') = 'pattern')
  2311.      * 
  2312.      * @param columnName
  2313.      * @param searchPattern
  2314.      */
  2315.     @Override
  2316.     public ISQLQueryObject addWhereDayOfYearCondition(String columnName,String searchPattern) throws SQLQueryObjectException{
  2317.         return addWhereCondition(columnName, searchPattern, DayFormatEnum.DAY_OF_YEAR);
  2318.     }
  2319.     
  2320.     /**
  2321.      * Aggiunge una condizione di ricerca
  2322.      * es: SELECT * from tabella WHERE (TO_CHAR(field, 'D') = 'pattern')
  2323.      * 
  2324.      * @param columnName
  2325.      * @param searchPattern
  2326.      */
  2327.     @Override
  2328.     public ISQLQueryObject addWhereDayOfWeekCondition(String columnName,String searchPattern) throws SQLQueryObjectException{
  2329.         return addWhereCondition(columnName, searchPattern, DayFormatEnum.DAY_OF_WEEK);
  2330.     }
  2331.     
  2332.     
  2333.     
  2334.     
  2335.     
  2336.     
  2337.     private String createWhereExistsCondition(boolean notExists,ISQLQueryObject sqlQueryObject)throws SQLQueryObjectException{
  2338.         if(sqlQueryObject==null)
  2339.             throw new SQLQueryObjectException("ISQLQueryObject, su cui viene effettuato il controllo di exists, non fornito");

  2341.         if(sqlQueryObject instanceof SQLQueryObjectCore){
  2342.             // http://stackoverflow.com/questions/5119190/oracle-sql-order-by-in-subquery-problems
  2343.             SQLQueryObjectCore core = (SQLQueryObjectCore) sqlQueryObject;
  2344.             if(core.orderBy!=null && !core.orderBy.isEmpty()){
  2345.                 throw new SQLQueryObjectException("ISQLQueryObject, su cui viene effettuato il controllo di exists, non deve possedere condizioni di order by");
  2346.             }
  2347.             if(core.offset>=0){
  2348.                 throw new SQLQueryObjectException("ISQLQueryObject, su cui viene effettuato il controllo di exists, non deve possedere la condizione di OFFSET");
  2349.             }
  2350.         }

  2352.         StringBuilder bf = new StringBuilder();
  2353.         if(notExists)
  2354.             bf.append("NOT ");
  2355.         bf.append("EXISTS (");
  2356.         bf.append(sqlQueryObject.createSQLQuery());
  2357.         bf.append(" )");
  2358.         return bf.toString();
  2359.     }

  2361.     /**
  2362.      * Aggiunge una condizione di ricerca con EXISTS
  2363.      * La query su cui viene effettuato il controllo di exists e' definito dal parametro sqlQueryObject
  2364.      * es. SELECT * from tabella WHERE [NOT] EXISTS ( sqlQueryObject.createSQLQuery() )
  2365.      * 
  2366.      * @param notExists Indicazione se applicare la negazione all'exists
  2367.      * @param sqlQueryObject query su cui viene effettuato il controllo di exists, la query viene prodotta attraverso il metodo createSQLQuery()
  2368.      * @throws SQLQueryObjectException
  2369.      */
  2370.     @Override
  2371.     public ISQLQueryObject addWhereExistsCondition(boolean notExists,ISQLQueryObject sqlQueryObject) throws SQLQueryObjectException{
  2372.         this.addWhereCondition(this.createWhereExistsCondition(notExists, sqlQueryObject));
  2373.         return this;
  2374.     }

  2376.     /**
  2377.      * Ritorna una condizione di ricerca con EXISTS
  2378.      * La query su cui viene effettuato il controllo di exists e' definito dal parametro sqlQueryObject
  2379.      * es. SELECT * from tabella WHERE [NOT] EXISTS ( sqlQueryObject.createSQLQuery() )
  2380.      * 
  2381.      * @param notExists Indicazione se applicare la negazione all'exists
  2382.      * @param sqlQueryObject query su cui viene effettuato il controllo di exists, la query viene prodotta attraverso il metodo createSQLQuery()
  2383.      * @throws SQLQueryObjectException
  2384.      */
  2385.     @Override
  2386.     public String getWhereExistsCondition(boolean notExists,ISQLQueryObject sqlQueryObject) throws SQLQueryObjectException{
  2387.         return this.createWhereExistsCondition(notExists, sqlQueryObject);
  2388.     }


  2391.     /**
  2392.      * Aggiunge una condizione di ricerca con sotto-select
  2393.      * La query su cui viene effettuato la ricerca della sotto-select e' definita dal parametro sqlQueryObject
  2394.      * es. SELECT * from tabella WHERE [NOT] field=( sqlQueryObject.createSQLQuery() )
  2395.      * esempio concreto:    SELECT * from tabella WHERE id=(select rif from riferimenti);
  2396.      * 
  2397.      * @param notExists Indicazione se applicare la negazione 
  2398.      * @param field Field su cui effettuare la select
  2399.      * @param sqlQueryObject query su cui viene effettuato la ricerca, la query viene prodotta attraverso il metodo createSQLQuery()
  2400.      * @throws SQLQueryObjectException
  2401.      */
  2402.     @Override
  2403.     public ISQLQueryObject addWhereSelectSQLCondition(boolean notExists,String field,ISQLQueryObject sqlQueryObject) throws SQLQueryObjectException{
  2404.         this.addWhereCondition(this.createWhereSQLConditionCondition(notExists,false,field,sqlQueryObject));
  2405.         return this;
  2406.     }

  2408.     /**
  2409.      * Aggiunge una condizione di ricerca con sotto-select
  2410.      * La query su cui viene effettuato la ricerca della sotto-select e' definita dal parametro sqlQueryObject
  2411.      * es. SELECT * from tabella WHERE [NOT] field IN ( sqlQueryObject.createSQLQuery() )
  2412.      * esempio concreto:    SELECT * from tabella WHERE id IN (select rif from riferimenti);
  2413.      * 
  2414.      * @param notExists Indicazione se applicare la negazione 
  2415.      * @param field Field su cui effettuare la select
  2416.      * @param sqlQueryObject query su cui viene effettuato la ricerca, la query viene prodotta attraverso il metodo createSQLQuery()
  2417.      * @throws SQLQueryObjectException
  2418.      */
  2419.     @Override
  2420.     public ISQLQueryObject addWhereINSelectSQLCondition(boolean notExists,String field,ISQLQueryObject sqlQueryObject) throws SQLQueryObjectException{
  2421.         this.addWhereCondition(this.createWhereSQLConditionCondition(notExists,true,field,sqlQueryObject));
  2422.         return this;
  2423.     }

  2425.     private String createWhereSQLConditionCondition(boolean notExists, boolean in,String field,ISQLQueryObject sqlQueryObject)throws SQLQueryObjectException{

  2427.         if(sqlQueryObject==null)
  2428.             throw new SQLQueryObjectException("ISQLQueryObject, su cui viene costruita la ricerca, non fornito");
  2429.         if(field==null)
  2430.             throw new SQLQueryObjectException("Field non fornito");

  2432.         if(sqlQueryObject instanceof SQLQueryObjectCore){
  2433.             // http://stackoverflow.com/questions/5119190/oracle-sql-order-by-in-subquery-problems
  2434.             SQLQueryObjectCore core = (SQLQueryObjectCore) sqlQueryObject;
  2435.             checkWhereSqlConditionConditionLimitOffse(in, core);
  2436.         }

  2438.         StringBuilder bf = new StringBuilder();
  2439.         if(notExists)
  2440.             bf.append("NOT ");
  2441.         bf.append(field);
  2442.         if(in)
  2443.             bf.append(" IN ");
  2444.         else
  2445.             bf.append(" = ");
  2446.         bf.append(" (");
  2447.         bf.append(sqlQueryObject.createSQLQuery());
  2448.         bf.append(" )");
  2449.         return bf.toString();
  2450.     }
  2451.     private void checkWhereSqlConditionConditionLimitOffse(boolean in,SQLQueryObjectCore core) throws SQLQueryObjectException {
  2452.         // http://stackoverflow.com/questions/5119190/oracle-sql-order-by-in-subquery-problems
  2453.         if(core.orderBy!=null && !core.orderBy.isEmpty()){
  2454.             throw new SQLQueryObjectException("ISQLQueryObject, su cui viene effettuato il controllo di exists, non deve possedere condizioni di order by");
  2455.         }
  2456.         if(core.offset>=0){
  2457.             throw new SQLQueryObjectException("ISQLQueryObject, su cui viene effettuato il controllo di exists, non deve possedere la condizione di OFFSET");
  2458.         }
  2459.         if(!in &&
  2460.             core.limit>1){
  2461.             throw new SQLQueryObjectException("ISQLQueryObject, su cui viene effettuato il controllo di exists, non deve possedere la condizione di LIMIT o al massimo puo' essere definita con valore '1')");
  2462.         }
  2463.     }

  2465.     /**
  2466.      * Imposta come operatore logico tra due o piu' condizioni esistenti l'AND se true, l'OR se false
  2467.      * 
  2468.      * @param andLogicOperator
  2469.      */
  2470.     @Override
  2471.     public void setANDLogicOperator(boolean andLogicOperator) throws SQLQueryObjectException{
  2472.         this.andLogicOperator = andLogicOperator;
  2473.     } // se false viene utilizzato OR tra le condizioni

  2475.     /**
  2476.      * Imposta il NOT prima delle condizioni NOT ( conditions )
  2477.      * 
  2478.      * @param not
  2479.      */
  2480.     @Override
  2481.     public void setNOTBeforeConditions(boolean not) throws SQLQueryObjectException{
  2482.         this.notBeforeConditions = not;
  2483.     } // se true viene utilizzato il NOT davanti alle condizioni






  2490.     // ESCAPE
  2491.     /**
  2492.      * Effettua l'escape di un valore di tipo stringa
  2493.      * 
  2494.      * @param value valore su cui effettuare l'escape
  2495.      * @return valore su cui e' stato effettuato l'escape
  2496.      * @throws SQLQueryObjectException
  2497.      */
  2498.     @Override
  2499.     public String escapeStringValue(String value) throws SQLQueryObjectException{

  2501.         return SQLQueryObjectCore.getEscapeStringValue(value);

  2503.     }
  2504.     public static String getEscapeStringValue(String value) throws SQLQueryObjectException{

  2506.         if(value==null){
  2507.             throw new SQLQueryObjectException("Valore non fornito per escape");
  2508.         }
  2509.         // converte ' in ''
  2510.         int index = value.indexOf('\'');
  2511.         if(index>=0){
  2512.             StringBuilder str =  new StringBuilder();
  2513.             char[] v = value.toCharArray();
  2514.             for(int i=0; i<v.length; i++){
  2515.                 if(v[i]=='\''){
  2516.                     str.append('\'');
  2517.                 }
  2518.                 str.append(v[i]);
  2519.             }
  2520.             return str.toString();
  2521.         }

  2523.         return value;
  2524.     }

  2526.     /**
  2527.      * Effettua l'escape di un pattern
  2528.      * 
  2529.      * @param pattern pattern su cui effettuare l'escape
  2530.      * @return pattern su cui e' stato effettuato l'escape
  2531.      * @throws SQLQueryObjectException
  2532.      */
  2533.     @Override
  2534.     public EscapeSQLPattern escapePatternValue(String pattern)
  2535.             throws SQLQueryObjectException {

  2537.         EscapeSQLPattern escapeSqlPattern = new EscapeSQLPattern();

  2539.         if(pattern==null){
  2540.             throw new SQLQueryObjectException("Valore non fornito per escape");
  2541.         }

  2543.         EscapeSQLConfiguration escapeConfig = this.getEscapeSQLConfiguration();

  2545.         StringBuilder str =  new StringBuilder();
  2546.         char[] v = pattern.toCharArray();
  2547.         for(int i=0; i<v.length; i++){
  2548.             
  2549.             if(escapeConfig.isDefaultEscape(v[i])){
  2550.                 str.append(escapeConfig.getEscape());

  2552.                 if(escapeConfig.isUseEscapeClausole()){
  2553.                     escapeSqlPattern.setUseEscapeClausole(true);
  2554.                     escapeSqlPattern.setEscapeClausole(escapeConfig.getEscape());
  2555.                 }
  2556.             }
  2557.             else if(escapeConfig.isOtherEscape(v[i])){
  2558.                 str.append(escapeConfig.getOtherEscapeCharacter(v[i]));
  2559.             }
  2560.             
  2561.             str.append(v[i]);

  2563.         }

  2565.         String returnStr = str.toString();  
  2566.         escapeSqlPattern.setEscapeValue(returnStr);
  2567.         return escapeSqlPattern;

  2569.     }
  2570.     protected abstract EscapeSQLConfiguration getEscapeSQLConfiguration();





  2576.     // GROUP BY

  2578.     /**
  2579.      * Aggiunge una condizione di GroupBy per i field con il nome sottostante.
  2580.      * I field devono essere precedentemente stati inseriti come SelectField
  2581.      * 
  2582.      * @param groupByNomeField Nome del field di raggruppamento
  2583.      */
  2584.     @Override
  2585.     public ISQLQueryObject addGroupBy(String groupByNomeField) throws SQLQueryObjectException{
  2586.         if(groupByNomeField==null || "".equals(groupByNomeField))
  2587.             throw new SQLQueryObjectException("GroupBy Condition is null or empty string");
  2588.         /**
  2589.          * Non e' sempre vero
  2590.          * if(this.fields.contains(groupByNomeField)==false){
  2591.          *  throw new SQLQueryObjectException("GroupBy Condition field non e' registrati tra i select field");
  2592.         }*/

  2594.         /**if(this.tableAlias.size()>0){
  2595.             throw new SQLQueryObjectException("Non e' possibile utilizzare alias nelle tabelle se poi si vuole usufruire della condizione GroupBy");
  2596.         } IL PROBLEMA DOVREBBE ESSERE STATO RISOLTO CON LA GESTIONE DEGLI ALIAS
  2597.          */
  2598.         if(this.alias.containsKey(groupByNomeField)){
  2599.             this.groupBy.add(this.alias.get(groupByNomeField));
  2600.         }
  2601.         else{
  2602.             this.groupBy.add(groupByNomeField); 
  2603.         }
  2604.         return this;
  2605.     }

  2607.     public List<String> getGroupByConditions() throws SQLQueryObjectException{
  2608.         if(this.groupBy!=null && !this.groupBy.isEmpty() &&
  2609.             this.fields.isEmpty()){
  2610.             throw new SQLQueryObjectException("Non e' possibile utilizzare condizioni di group by se non sono stati indicati select field");
  2611.         }
  2612.         return this.groupBy;
  2613.     }


  2616.     // ORDER BY

  2618.     /**
  2619.      * Aggiunge una condizione di OrderBy per i field con il nome sottostante.
  2620.      * I field devono essere precedentemente stati inseriti come SelectField
  2621.      * 
  2622.      * @param orderByNomeField Nome del field di ordinamento
  2623.      */
  2624.     @Override
  2625.     public ISQLQueryObject addOrderBy(String orderByNomeField) throws SQLQueryObjectException{
  2626.         if(orderByNomeField==null || "".equals(orderByNomeField))
  2627.             throw new SQLQueryObjectException("OrderBy Condition is null or empty string");
  2628.         /**
  2629.          * Non e' sempre vero
  2630.          * if(this.fields.contains(orderByNomeField)==false){
  2631.          *  throw new SQLQueryObjectException("OrderBy Condition field non e' registrati tra i select field");
  2632.         }*/
  2633.         this.orderBy.add(orderByNomeField);
  2634.         return this;
  2635.     }

  2637.     /**
  2638.      * Aggiunge una condizione di OrderBy per i field con il nome sottostante.
  2639.      * I field devono essere precedentemente stati inseriti come SelectField
  2640.      * 
  2641.      * @param orderByNomeField Nome del field di ordinamento
  2642.      * @param asc Imposta la stringa di ordinamento (Crescente:true/Decrescente:false)
  2643.      */
  2644.     @Override
  2645.     public ISQLQueryObject addOrderBy(String orderByNomeField, boolean asc) throws SQLQueryObjectException{
  2646.         this.addOrderBy(orderByNomeField);
  2647.         this.orderBySortType.put(orderByNomeField, asc);
  2648.         return this;
  2649.     }

  2651.     /**
  2652.      * Imposta la stringa di ordinamento (Crescente:true/Decrescente:false)
  2653.      */
  2654.     @Override
  2655.     public void setSortType(boolean sort) throws SQLQueryObjectException{
  2656.         if(this.orderBy.isEmpty())
  2657.             throw new SQLQueryObjectException("OrderBy Conditions non definite");
  2658.         this.sortTypeAsc = sort;
  2659.     }




  2664.     // LIMIT E OFFSET

  2666.     /**
  2667.      * Aggiunge un limite ai risultati ritornati
  2668.      * 
  2669.      * @param limit limite dei risultati ritornati
  2670.      */
  2671.     @Override
  2672.     public void setLimit(int limit) throws SQLQueryObjectException{
  2673.         this.limit = limit;
  2674.     }

  2676.     public int getLimit() {
  2677.         return this.limit;
  2678.     }

  2680.     /**
  2681.      * Aggiunge un offset per i risultati ritornati
  2682.      * 
  2683.      * @param offset offset per i risultati ritornati
  2684.      */
  2685.     @Override
  2686.     public void setOffset(int offset) throws SQLQueryObjectException{
  2687.         this.offset = offset;
  2688.     }

  2690.     public int getOffset() {
  2691.         return this.offset;
  2692.     }

  2694.     
  2695.     // SELECT FOR UPDATE
  2696.     
  2697.     public boolean isSelectForUpdate() {
  2698.         return this.selectForUpdate;
  2699.     }
  2700.     
  2701.     @Override
  2702.     public void setSelectForUpdate(boolean selectForUpdate) throws SQLQueryObjectException {
  2703.         this.selectForUpdate = selectForUpdate;
  2704.     }
  2705.     
  2706.     protected void checkSelectForUpdate(boolean update,boolean delete, boolean union) throws SQLQueryObjectException{
  2707.         if(this.selectForUpdate){
  2708.             String tipo = null;
  2709.             if(update){
  2710.                 tipo = "UPDATE";
  2711.             }
  2712.             else if(delete){
  2713.                 tipo = "DELETE";
  2714.             }
  2715.             else if(union){
  2716.                 tipo = "UNION";
  2717.             }
  2718.             else if(!this.getGroupByConditions().isEmpty()){
  2719.                 tipo = "GROUP BY";
  2720.             }
  2721.             else if(this.isSelectDistinct()){
  2722.                 tipo = "DISTINCT";
  2723.             }
  2724.             else if(this.limit>=0){
  2725.                 tipo = "LIMIT";
  2726.             }
  2727.             else if(this.offset>=0){
  2728.                 tipo = "OFFSET";
  2729.             }
  2730.             if(tipo!=null)
  2731.                 throw new SQLQueryObjectException("Utilizzo dell'opzione 'FOR UPDATE' non permesso con il comando "+tipo);
  2732.         }
  2733.     }
  2734.     
  2735.     

  2737.     // GENERAZIONE SQL

  2739.     /**
  2740.      * Crea una SQL Query con i dati dell'oggetto
  2741.      * 
  2742.      * @return SQL Query
  2743.      */
  2744.     /**@Override
  2745.     public abstract String createSQLQuery() throws SQLQueryObjectException;*/

  2747.     @Override
  2748.     public String toString(){
  2749.         try{
  2750.             return this.createSQLQuery();
  2751.         }catch(Exception e){
  2752.             return "Oggetto non corretto: "+e.getMessage();
  2753.         }
  2754.     }

  2756.     protected void checkUnionField(boolean count,ISQLQueryObject... sqlQueryObject)throws SQLQueryObjectException{

  2758.         if(count){
  2759.             checkUnionFieldCount();
  2760.         }

  2762.         if(this.offset>=0 &&
  2763.             this.fields.isEmpty()) {
  2764.             throw new SQLQueryObjectException("Non e' possibile usare offset se non e' stato indicato alcun field nella select piu' esterna della union");
  2765.         }
  2766.         if(this.limit>0 &&
  2767.             this.fields.isEmpty()) {
  2768.             throw new SQLQueryObjectException("Non e' possibile usare limit se non e' stato indicato alcun field nella select piu' esterna della union");
  2769.         }

  2771.         if(this.distinct){
  2772.             throw new SQLQueryObjectException("Non e' possibile usare distinct nella select piu' esterna della union (utilizza il parametro boolean unionAll)");
  2773.         }

  2775.         if(sqlQueryObject==null || sqlQueryObject.length<=0){
  2776.             throw new SQLQueryObjectException("Parametro is null");
  2777.         }
  2778.         if(sqlQueryObject.length==1){
  2779.             throw new SQLQueryObjectException("Parametro contiene un solo sqlQueryObject (minimo 2)");
  2780.         }

  2782.         // Check presenza fields
  2783.         checkUnionFieldExists(sqlQueryObject);

  2785.         // Check nomi fields            
  2786.         checkUnionFieldNames(sqlQueryObject);

  2788.         // Check presenza order by DEVE essere accompagnata da un offset in modo che venga generata la condizione di order by su Oracle/SLQServer per le condizioni
  2789.         checkUnionFieldOrderOffset(sqlQueryObject);
  2790.         
  2791.         // Check Select For Update
  2792.         if(this.selectForUpdate){
  2793.             throw new SQLQueryObjectException("Non è possibile abilitare il comando 'selectForUpdate' con la UNION");
  2794.         }
  2795.     }
  2796.     protected void checkUnionFieldCount() throws SQLQueryObjectException{
  2797.         if(this.orderBy!=null && !this.orderBy.isEmpty()){
  2798.             throw new SQLQueryObjectException("Non e' possibile usare order by in una count");
  2799.         }
  2800.         if(this.limit>0){
  2801.             throw new SQLQueryObjectException("Non e' possibile usare limit in una count");
  2802.         }
  2803.         if(this.offset>=0){
  2804.             throw new SQLQueryObjectException("Non e' possibile usare offset in una count");
  2805.         }
  2806.     }
  2807.     protected void checkUnionFieldExists(ISQLQueryObject... sqlQueryObject)throws SQLQueryObjectException{
  2808.         for(int i=0;i<sqlQueryObject.length;i++){
  2809.             ISQLQueryObject sqlQueryObjectDaVerificare = sqlQueryObject[i];
  2810.             List<String> nomiFieldSqlQueryObjectDaVerificare = sqlQueryObjectDaVerificare.getFieldsName();
  2811.             if(nomiFieldSqlQueryObjectDaVerificare==null || nomiFieldSqlQueryObjectDaVerificare.isEmpty()){
  2812.                 throw new SQLQueryObjectException("La select numero "+(i+1)+" non possiede fields?");
  2813.             }
  2814.         }
  2815.     }
  2816.     protected void checkUnionFieldNames(ISQLQueryObject... sqlQueryObject)throws SQLQueryObjectException{
  2817.         /**     for(int i=0;i<sqlQueryObject.length;i++){
  2818.         //          System.out.println("CHECK ["+i+"] ...");
  2819.         //          List<String> nomiFieldSqlQueryObjectDaVerificare = sqlQueryObject[i].getFieldsName();
  2820.         //          for (String string : nomiFieldSqlQueryObjectDaVerificare) {
  2821.         //              System.out.println("\t-"+string);
  2822.         //          }
  2823.         //      }*/
  2824.         for(int i=0;i<sqlQueryObject.length;i++){

  2826.             List<String> nomiFieldSqlQueryObjectDaVerificare = sqlQueryObject[i].getFieldsName();
  2827.             String [] nomi = nomiFieldSqlQueryObjectDaVerificare.toArray(new String[1]);

  2829.             for(int indiceField =0; indiceField<nomi.length;indiceField++){

  2831.                 String fieldDaVerificare = nomi[indiceField];

  2833.                 for(int altriSqlObject=0;altriSqlObject<sqlQueryObject.length;altriSqlObject++){

  2835.                     if(altriSqlObject==i){
  2836.                         // e' l'oggetto in questione
  2837.                         continue;
  2838.                     }

  2840.                     if( (!sqlQueryObject[altriSqlObject].getFieldsName().contains(fieldDaVerificare)) &&
  2841.                             (!sqlQueryObject[altriSqlObject].getFieldsName().contains("*")) ){
  2842.                         throw new SQLQueryObjectException("Field ["+fieldDaVerificare+"] trovato nella select numero "+(i+1) +" non presente nella select numero "+(altriSqlObject+1) +" (Se sono campi diversi usare lo stesso alias)");
  2843.                     }
  2844.                 }
  2845.             }
  2846.         }
  2847.     }
  2848.     protected void checkUnionFieldOrderOffset(ISQLQueryObject... sqlQueryObject)throws SQLQueryObjectException{
  2849.         for(int i=0;i<sqlQueryObject.length;i++){
  2850.             SQLQueryObjectCore sqlQueryObjectDaVerificare = (SQLQueryObjectCore) sqlQueryObject[i];
  2851.             if(sqlQueryObjectDaVerificare.orderBy!=null && !sqlQueryObjectDaVerificare.orderBy.isEmpty() &&
  2852.                 sqlQueryObjectDaVerificare.offset<0){
  2853.                 /**throw new SQLQueryObjectException("La select numero "+(i+1)+" per poter essere utilizzata nella UNION, siccome presenta condizioni di ordinamento, deve specificare anche l'offset");*/
  2854.                 sqlQueryObjectDaVerificare.setOffset(0); // Se viene messo il limit, l'offset cmq parte da 0
  2855.             }
  2856.         }
  2857.     }



  2861.     /* ---------------- UPDATE ------------------ */

  2863.     /**
  2864.      * Definisce la tabella su cui deve essere effettuato l'update
  2865.      * es: UPDATE table set ...
  2866.      * 
  2867.      * @param nomeTabella Nome della tabella
  2868.      */
  2869.     @Override
  2870.     public ISQLQueryObject addUpdateTable(String nomeTabella) throws SQLQueryObjectException{
  2871.         if(nomeTabella==null || "".equals(nomeTabella))
  2872.             throw new SQLQueryObjectException("Nome tabella is null or empty string");
  2873.         this.updateTable = nomeTabella;
  2874.         return this;
  2875.     }

  2877.     /**
  2878.      * Aggiunge un field per l'update
  2879.      * es: UPDATE table set nomeField=valueField WHERE ...
  2880.      * 
  2881.      * @param nomeField Nome del Field
  2882.      */
  2883.     @Override
  2884.     public ISQLQueryObject addUpdateField(String nomeField,String valueField) throws SQLQueryObjectException{
  2885.         if(nomeField==null || "".equals(nomeField))
  2886.             throw new SQLQueryObjectException(FIELD_NAME_IS_NULL_OR_EMPTY);
  2887.         if(valueField==null)
  2888.             throw new SQLQueryObjectException("Field value is null");
  2889.         if(this.updateFieldsName.contains(nomeField)){
  2890.             throw new SQLQueryObjectException(FIELD_NAME_PREFIX+nomeField+" gia inserito tra gli update fields");
  2891.         }else{
  2892.             this.updateFieldsName.add(nomeField);
  2893.             this.updateFieldsValue.add(valueField);
  2894.         }
  2895.         return this;
  2896.     }
  2897.     
  2898.     @Override
  2899.     public ISQLQueryObject addUpdateField(String nomeField,Case caseValue) throws SQLQueryObjectException{
  2900.         if(nomeField==null || "".equals(nomeField))
  2901.             throw new SQLQueryObjectException(FIELD_NAME_IS_NULL_OR_EMPTY);
  2902.         
  2903.         if(this.updateFieldsName.contains(nomeField)){
  2904.             throw new SQLQueryObjectException(FIELD_NAME_PREFIX+nomeField+" gia inserito tra gli update fields");
  2905.         }else{
  2906.             String caseCondition = getCaseCondition(caseValue);
  2907.                                     
  2908.             this.updateFieldsName.add(nomeField);
  2909.             this.updateFieldsValue.add(caseCondition);
  2910.         }
  2911.         return this;
  2912.     }
  2913.     protected String getPrefixCastValue(CastColumnType type, int length) {
  2914.         if(type!=null && length>0) {
  2915.             // nop
  2916.         }
  2917.         return "";
  2918.     }
  2919.     protected String getSuffixCastValue(CastColumnType type, int length) {
  2920.         if(type!=null || length>0) {
  2921.             // nop
  2922.         }
  2923.         return "";
  2924.     }
  2925.     
  2926.     @Override
  2927.     public String createSQLUpdate() throws SQLQueryObjectException{
  2928.         
  2929.         if(this.updateTable==null)
  2930.             throw new SQLQueryObjectException("Nome Tabella per l'aggiornamento non definito");
  2931.         if(this.updateFieldsName.isEmpty())
  2932.             throw new SQLQueryObjectException("Nessuna coppia nome/valore da aggiornare presente");
  2933.         if(this.updateFieldsName.size()!= this.updateFieldsValue.size()){
  2934.             throw new SQLQueryObjectException("FieldsName.size["+this.updateFieldsName.size()+"] <> FieldsValue.size["+this.updateFieldsValue.size()+"]");
  2935.         }
  2936.         
  2937.         if(this.forceSelectForUpdateDisabledForNotQueryMethod){
  2938.             
  2939.             // Per permettere di usare l'oggetto sqlQueryObject con più comandi
  2940.             boolean oldValueSelectForUpdate = this.selectForUpdate;
  2941.             try{
  2942.                 this.selectForUpdate = false;
  2943.                 return this.createSQLUpdateEngine();
  2944.             }finally{
  2945.                 this.selectForUpdate = oldValueSelectForUpdate;
  2946.             }
  2947.             
  2948.         }
  2949.         else{
  2950.             return this.createSQLUpdateEngine();
  2951.         }
  2952.     }
  2953.     
  2954.     protected abstract String createSQLUpdateEngine() throws SQLQueryObjectException;





  2960.     /* ---------------- INSERT ------------------ */

  2962.     /**
  2963.      * Definisce la tabella su cui deve essere effettuato l'insert
  2964.      * es: INSERT INTO table (XX) VALUES (VV) 
  2965.      * 
  2966.      * @param nomeTabella Nome della tabella
  2967.      */
  2968.     @Override
  2969.     public ISQLQueryObject addInsertTable(String nomeTabella) throws SQLQueryObjectException{
  2970.         if(nomeTabella==null || "".equals(nomeTabella))
  2971.             throw new SQLQueryObjectException("Nome tabella is null or empty string");
  2972.         this.insertTable = nomeTabella;
  2973.         return this;
  2974.     }

  2976.     /**
  2977.      * Aggiunge un field per la insert
  2978.      * es: INSERT INTO table (nomeField) VALUES (valueField)
  2979.      * 
  2980.      * @param nomeField Nome del Field
  2981.      */
  2982.     @Override
  2983.     public ISQLQueryObject addInsertField(String nomeField,String valueField) throws SQLQueryObjectException{
  2984.         if(nomeField==null || "".equals(nomeField))
  2985.             throw new SQLQueryObjectException(FIELD_NAME_IS_NULL_OR_EMPTY);
  2986.         if(valueField==null)
  2987.             throw new SQLQueryObjectException("Field value is null");
  2988.         if(this.insertFieldsName.contains(nomeField)){
  2989.             throw new SQLQueryObjectException(FIELD_NAME_PREFIX+nomeField+" gia inserito tra gli insert fields");
  2990.         }else{
  2991.             this.insertFieldsName.add(nomeField);
  2992.             this.insertFieldsValue.add(valueField);
  2993.         }
  2994.         return this;
  2995.     }

  2997.     /**
  2998.      * Crea una SQL per una operazione di Insert con i dati dell'oggetto
  2999.      * 
  3000.      * @return SQL per una operazione di Insert
  3001.      */
  3002.     @Override
  3003.     public String createSQLInsert() throws SQLQueryObjectException{
  3004.         
  3005.         if(this.insertTable==null)
  3006.             throw new SQLQueryObjectException("Nome Tabella per l'inserimento non definito");
  3007.         if(this.insertFieldsName.isEmpty())
  3008.             throw new SQLQueryObjectException("Nessuna coppia nome/valore da inserire presente");
  3009.         if(this.insertFieldsName.size()!= this.insertFieldsValue.size()){
  3010.             throw new SQLQueryObjectException("FieldsName.size <> FieldsValue.size");
  3011.         }

  3013.         if(this.forceSelectForUpdateDisabledForNotQueryMethod){
  3014.         
  3015.             // Per permettere di usare l'oggetto sqlQueryObject con più comandi
  3016.             boolean oldValueSelectForUpdate = this.selectForUpdate;
  3017.             try{
  3018.                 this.selectForUpdate = false;
  3019.                 return this.createSQLInsertEngine();
  3020.             }finally{
  3021.                 this.selectForUpdate = oldValueSelectForUpdate;
  3022.             }
  3023.             
  3024.         }
  3025.         else{
  3026.             return this.createSQLInsertEngine();
  3027.         }
  3028.         

  3030.     }
  3031.     private String createSQLInsertEngine() {
  3032.         StringBuilder bf = new StringBuilder();
  3033.         bf.append("INSERT INTO ");
  3034.         bf.append(this.insertTable);
  3035.         bf.append(" (");
  3036.         for(int i=0; i<this.insertFieldsName.size(); i++){
  3037.             if(i>0)
  3038.                 bf.append(",");
  3039.             bf.append(this.insertFieldsName.get(i));
  3040.         }
  3041.         bf.append(") VALUES (");
  3042.         for(int i=0; i<this.insertFieldsValue.size(); i++){
  3043.             if(i>0)
  3044.                 bf.append(",");
  3045.             bf.append(this.insertFieldsValue.get(i));
  3046.         }
  3047.         bf.append(")");
  3048.         return bf.toString();
  3049.     }





  3055.     /* ---------------- DELETE ------------------ */

  3057.     /**
  3058.      * Aggiunge una tabella di ricerca del from
  3059.      * es: DELETE from tabella
  3060.      * 
  3061.      * @param tabella
  3062.      */
  3063.     @Override
  3064.     public ISQLQueryObject addDeleteTable(String tabella) throws SQLQueryObjectException{
  3065.         checkDeleteTable(tabella);
  3066.         this.addFromTable(tabella);
  3067.         return this;
  3068.     }
  3069.     
  3070.     @Override
  3071.     public String createSQLDelete() throws SQLQueryObjectException {

  3073.         // Table dove effettuare la ricerca 'FromTable'
  3074.         if(this.tables.isEmpty()){
  3075.             throw new SQLQueryObjectException("Non e' possibile creare un comando di delete senza aver definito le tabelle su cui apportare l'eliminazione dei dati");
  3076.         }else{
  3077.             Iterator<String> it = this.tables.iterator();
  3078.             while(it.hasNext()){
  3079.                 String table = it.next();
  3080.                 checkDeleteTable(table);
  3081.             }
  3082.         }

  3084.         if(this.forceSelectForUpdateDisabledForNotQueryMethod){
  3085.             
  3086.             // Per permettere di usare l'oggetto sqlQueryObject con più comandi
  3087.             boolean oldValueSelectForUpdate = this.selectForUpdate;
  3088.             try{
  3089.                 this.selectForUpdate = false;
  3090.                 return this.createSQLDeleteEngine();
  3091.             }finally{
  3092.                 this.selectForUpdate = oldValueSelectForUpdate;
  3093.             }
  3094.             
  3095.         }
  3096.         else{
  3097.             return this.createSQLDeleteEngine();
  3098.         }
  3099.     }
  3100.     
  3101.     protected abstract String createSQLDeleteEngine() throws SQLQueryObjectException;
  3102.     
  3103.     private void checkDeleteTable(String tabella) throws SQLQueryObjectException{
  3104.         // Controllo quelli standard (da fare per impostare il controllo in ogni classe)
  3105.         if(tabella.contains(" as ") || tabella.contains(" ")){
  3106.             throw new SQLQueryObjectException("Non e' possibile utilizzare tabelle definite tramite alias in caso di delete");
  3107.         }

  3109.         List<String> asModeSupportati = this.getSupportedAliasesTable();
  3110.         for (Iterator<?> iterator = asModeSupportati.iterator(); iterator.hasNext();) {
  3111.             String aliasMode = (String) iterator.next();
  3112.             if(tabella.contains(aliasMode)){
  3113.                 throw new SQLQueryObjectException("Non e' possibile utilizzare tabelle definite tramite alias in caso di delete");
  3114.             }
  3115.         }
  3116.     }
  3117.     
  3118.     
  3119.     
  3120.     
  3121.     
  3122.     /* ---------------- WHERE CONDITIONS ------------------ */
  3123.     
  3124.     @Override
  3125.     public String createSQLConditions() throws SQLQueryObjectException{
  3126.         
  3127.         if(this.conditions==null)
  3128.             throw new SQLQueryObjectException("Condizioni non definite");
  3129.         if(this.conditions.isEmpty())
  3130.             throw new SQLQueryObjectException("Nessuna condizione presente");
  3131.         
  3132.         if(this.forceSelectForUpdateDisabledForNotQueryMethod){
  3133.             
  3134.             // Per permettere di usare l'oggetto sqlQueryObject con più comandi
  3135.             boolean oldValueSelectForUpdate = this.selectForUpdate;
  3136.             try{
  3137.                 this.selectForUpdate = false;
  3138.                 return this.createSQLConditionsEngine();
  3139.             }finally{
  3140.                 this.selectForUpdate = oldValueSelectForUpdate;
  3141.             }
  3142.             
  3143.         }
  3144.         else{
  3145.             return this.createSQLConditionsEngine();
  3146.         }
  3147.     }

  3149.     protected abstract String createSQLConditionsEngine() throws SQLQueryObjectException;







  3157.     /* ---------------- NEW SQL QUERY OBJECT ------------------ */

  3159.     /**
  3160.      * Inizializza un nuovo SQLQueryObject
  3161.      * 
  3162.      * @return SQLQueryObject
  3163.      * 
  3164.      * @throws SQLQueryObjectException
  3165.      */
  3166.     @Override
  3167.     public ISQLQueryObject newSQLQueryObject() throws SQLQueryObjectException{
  3168.         return SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  3169.     }

  3171.     /**
  3172.      * Indicazione sul tipo di database
  3173.      * 
  3174.      * @return tipo di database
  3175.      * 
  3176.      * @throws SQLQueryObjectException
  3177.      */
  3178.     @Override
  3179.     public String getTipoDatabase() throws SQLQueryObjectException{
  3180.         return this.tipoDatabase.toString();
  3181.     }

  3183.     /**
  3184.      * Indicazione sul tipo di database
  3185.      * 
  3186.      * @return tipo di database
  3187.      * 
  3188.      * @throws SQLQueryObjectException
  3189.      */
  3190.     @Override
  3191.     public TipiDatabase getTipoDatabaseOpenSPCoop2() throws SQLQueryObjectException{
  3192.         return this.tipoDatabase;
  3193.     }
  3194. }
Created with JaCoCo 0.8.8.202204050719