OracleQueryObject.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;


  26. import java.text.SimpleDateFormat;
  27. import java.util.ArrayList;
  28. import java.util.Date;
  29. import java.util.Iterator;
  30. import java.util.List;

  32. import org.openspcoop2.utils.TipiDatabase;
  33. import org.openspcoop2.utils.date.DateUtils;



  37. /**
  38.  * Classe dove vengono forniti utility per la conversione di comandi SQL per il database oracle 
  39.  * 
  40.  *
  41.  * @author Poli Andrea (apoli@link.it)
  42.  * @author $Author$
  43.  * @version $Rev$, $Date$
  44.  */
  45. public class OracleQueryObject extends SQLQueryObjectCore{
  46.     
  47.     public OracleQueryObject(TipiDatabase tipoDatabase) {
  48.         super(tipoDatabase);
  49.     }
  50.     
  51.     
  52.     // GESTIONE LIMIT SENZA OFFSET
  53.     // Se viene impostato OrderBy, e l'offset non e' impostato, deve essere impostato, altrimenti il limit funziona, pero' non ritorna un risultato ordinato.
  54.     @Override
  55.     public ISQLQueryObject addOrderBy(String orderByNomeField) throws SQLQueryObjectException{
  56.         if(this.offset<0 && this.limit>=0){
  57.             super.setOffset(0);
  58.         }
  59.         return super.addOrderBy(orderByNomeField);
  60.     }
  61.     @Override
  62.     public void setLimit(int limit) throws SQLQueryObjectException{
  63.         if(this.offset<0 && !this.orderBy.isEmpty()){
  64.             this.offset = 0;
  65.         }
  66.         super.setLimit(limit);
  67.     }
  68.     
  69.     
  70.     
  71.     // GESTIONE ALIAS 'as'
  72.     // Non tutti i database supportano l'alias 'as', ad esempio Oracle genera un errore se viene usato l'alias con le tabelle.
  73.     @Override
  74.     public String getDefaultAliasTableKeyword(){
  75.         return this.getSupportedAliasesTable().get(0);
  76.     }
  77.     @Override
  78.     public List<String> getSupportedAliasesTable(){
  79.         List<String> lista = new ArrayList<>();
  80.         lista.add(" ");
  81.         return lista;
  82.     }
  83.     
  84.     
  85.     
  86.     
  87.     /**
  88.      * Ritorna una costante  di tipo 'timestamp'
  89.      * 
  90.      * @param date Costante
  91.      */
  92.     @Override
  93.     public String getSelectTimestampConstantField(Date date) throws SQLQueryObjectException{
  94.         SimpleDateFormat sqlDateformat = DateUtils.getDefaultDateTimeFormatter("yyyy-MM-dd HH:mm:ss.SSS");
  95.         return "TO_TIMESTAMP('"+sqlDateformat.format(date)+"', 'YYYY-MM-DD HH24:MI:SS.FF3')";
  96.     }
  97.     
  98.     
  99.     
  100.     @Override
  101.     public String getUnixTimestampConversion(String column){
  102.         String timeZone = null;/**"Europe/Rome";*/
  103.         timeZone = java.util.TimeZone.getDefault().getID(); // fix: uso il timeZone di sistema
  104.         return "("+
  105.                 "(((cast("+column+" as date) - to_date('19700101','YYYYMMDD')) * 86400 * 1000) + to_number(to_char("+column+",'FF3'))) - "+             
  106.                 "( (EXTRACT (timezone_hour from FROM_TZ ("+column+",(TZ_OFFSET('"+timeZone+"'))))) *60*60*1000 ) "+
  107.                 ")";
  108.                 
  109.     }
  110.     
  111.     @Override
  112.     public String getDiffUnixTimestamp(String columnMax,String columnMin){
  113.         return "("+
  114.                 "(extract( day from  ("+columnMax+" - "+columnMin+"))*24*60*60*1000)"+
  115.                 "+"+
  116.                 "(extract( hour from ("+columnMax+" - "+columnMin+"))*60*60*1000)"+
  117.                 "+"+
  118.                 "(extract( minute from ("+columnMax+" - "+columnMin+"))*60*1000)"+
  119.                 "+"+
  120.                 "round(extract( second from ("+columnMax+" - "+columnMin+"))*1000)"+
  121.                 ")";
  122.     }

  124.     
  125.     
  126.     
  127.     /**
  128.      * Aggiunge un field count alla select, con un alias, del campo <var>fieldAvg</var> (di tipo Timestamp)
  129.      * es: SELECT avg(fieldAvg) as alias FROM ....
  130.      * 
  131.       * @param field Nome del Field
  132.      * @param alias Alias
  133.      */
  134.     @Override
  135.     public ISQLQueryObject addSelectAvgTimestampField(String field,String alias) throws SQLQueryObjectException{
  136.         if(field==null)
  137.             throw new SQLQueryObjectException(SQLQueryObjectCore.FIELD_DEVE_ESSERE_DIVERSO_NULL);
  138.         // Trasformo in UNIX_TIMESTAMP
  139.         String fieldSQL = "avg("+this.getUnixTimestampConversion(field)+")";
  140.         if(alias != null){
  141.             /**fieldSQL = fieldSQL + " as "+alias;*/
  142.             fieldSQL = fieldSQL + this.getDefaultAliasFieldKeyword() + alias;
  143.         }
  144.         this.engineAddSelectField(null,fieldSQL,null,false,true);
  145.         this.fieldNames.add(alias);
  146.         return this;
  147.     }
  148.     
  149.     
  150.     /**
  151.      * Aggiunge un field count alla select, con un alias, del campo <var>field</var> (di tipo Timestamp)
  152.      * es: SELECT max(field) as alias FROM ....
  153.      * 
  154.       * @param field Nome del Field
  155.      * @param alias Alias
  156.      */
  157.     @Override
  158.     public ISQLQueryObject addSelectMaxTimestampField(String field,String alias) throws SQLQueryObjectException{
  159.         if(field==null)
  160.             throw new SQLQueryObjectException(SQLQueryObjectCore.FIELD_DEVE_ESSERE_DIVERSO_NULL);
  161.         // Trasformo in UNIX_TIMESTAMP
  162.         String fieldSQL = "max("+this.getUnixTimestampConversion(field)+")";
  163.         if(alias != null){
  164.             /**fieldSQL = fieldSQL + " as "+alias;*/
  165.             fieldSQL = fieldSQL + this.getDefaultAliasFieldKeyword() + alias;
  166.         }
  167.         this.engineAddSelectField(null,fieldSQL,null,false,true);
  168.         this.fieldNames.add(alias);
  169.         return this;
  170.     }
  171.     
  172.     /**
  173.      * Aggiunge un field count alla select, con un alias, del campo <var>field</var> (di tipo Timestamp)
  174.      * es: SELECT min(field) as alias FROM ....
  175.      * 
  176.      * @param field Nome del Field
  177.      * @param alias
  178.      */
  179.     @Override
  180.     public ISQLQueryObject addSelectMinTimestampField(String field,String alias) throws SQLQueryObjectException{
  181.         if(field==null)
  182.             throw new SQLQueryObjectException(SQLQueryObjectCore.FIELD_DEVE_ESSERE_DIVERSO_NULL);
  183.         // Trasformo in UNIX_TIMESTAMP
  184.         String fieldSQL = "min("+this.getUnixTimestampConversion(field)+")";
  185.         if(alias != null){
  186.             /**fieldSQL = fieldSQL + " as "+alias;*/
  187.             fieldSQL = fieldSQL + this.getDefaultAliasFieldKeyword() + alias;
  188.         }
  189.         this.engineAddSelectField(null,fieldSQL,null,false,true);
  190.         this.fieldNames.add(alias);
  191.         return this;
  192.     }
  193.     
  194.     /**
  195.      * Aggiunge un field count alla select, con un alias, del campo <var>field</var> (di tipo Timestamp)
  196.      * es: SELECT sum(field) as alias FROM ....
  197.      * 
  198.      * @param field Nome del Field
  199.      * @param alias
  200.      */
  201.     @Override
  202.     public ISQLQueryObject addSelectSumTimestampField(String field,String alias) throws SQLQueryObjectException{
  203.         if(field==null)
  204.             throw new SQLQueryObjectException(SQLQueryObjectCore.FIELD_DEVE_ESSERE_DIVERSO_NULL);
  205.         // Trasformo in UNIX_TIMESTAMP
  206.         String fieldSQL = "sum("+this.getUnixTimestampConversion(field)+")";
  207.         if(alias != null){
  208.             /**fieldSQL = fieldSQL + " as "+alias;*/
  209.             fieldSQL = fieldSQL + this.getDefaultAliasFieldKeyword() + alias;
  210.         }
  211.         this.engineAddSelectField(null,fieldSQL,null,false,true);
  212.         this.fieldNames.add(alias);
  213.         return this;
  214.     }
  215.     
  216.     
  217.     /**
  218.      * Aggiunge una tabella di ricerca del from
  219.      * es: SELECT * from ( subSelect )
  220.      * 
  221.      * @param subSelect subSelect
  222.      */
  223.     @Override
  224.     public ISQLQueryObject addFromTable(ISQLQueryObject subSelect) throws SQLQueryObjectException{
  225.         StringBuilder bf = new StringBuilder();
  226.         bf.append(" ( ");
  227.         bf.append(subSelect.createSQLQuery());
  228.         bf.append(" ) ");
  229.         this.addFromTable(bf.toString());
  230.         return this;
  231.     }
  232.     
  233.     
  234.     
  235.     
  236.     
  237.     @Override
  238.     protected EscapeSQLConfiguration getEscapeSQLConfiguration(){
  239.         
  240.         EscapeSQLConfiguration config = new EscapeSQLConfiguration();
  241.         config.addCharacter('_');
  242.         config.addCharacter('%');
  243.         config.addCharacter('\\');
  244.         config.setUseEscapeClausole(true);
  245.         config.setEscape('\\');
  246.         
  247.         // special
  248.         config.addCharacterWithOtherEscapeChar('\'','\'');
  249.         
  250.         return config;
  251.     }

  253.     
  254.     
  255.     @Override
  256.     public ISQLQueryObject addSelectForceIndex(String nomeTabella,String indexName) throws SQLQueryObjectException{
  257.         if(nomeTabella==null || "".equals(nomeTabella))
  258.             throw new SQLQueryObjectException("Nome tabela is null or empty string");
  259.         if(indexName==null || "".equals(indexName))
  260.             throw new SQLQueryObjectException("Nome indice is null or empty string");
  261.         String forceIndex = "/*+ index("+nomeTabella+" "+indexName+") */";
  262.         if(this.forceIndexTableNames.contains(forceIndex)){
  263.             throw new SQLQueryObjectException("Forzatura all'utilizzo dell'indice ("+forceIndex+") gia inserito tra le forzature");
  264.         }
  265.         this.forceIndexTableNames.add(forceIndex);
  266.         return this;
  267.     }
  268.     

  270.     
  271.     
  272.     
  273.     
  274.     @Override
  275.     public String getExtractDayFormatFromTimestampFieldPrefix(DayFormatEnum dayFormat) throws SQLQueryObjectException {
  276.         if(dayFormat==null) {
  277.             throw new SQLQueryObjectException("dayFormat undefined");
  278.         }
  279.         if(DayFormatEnum.FULL_DAY_NAME.equals(dayFormat)) {
  280.             return "TRIM(BOTH FROM TO_CHAR(";
  281.         }
  282.         else {
  283.             return super.getExtractDayFormatFromTimestampFieldPrefix(dayFormat);
  284.         }
  285.     }
  286.     @Override
  287.     public String getExtractDayFormatFromTimestampFieldSuffix(DayFormatEnum dayFormat) throws SQLQueryObjectException {
  288.         if(DayFormatEnum.FULL_DAY_NAME.equals(dayFormat)) {
  289.             return super.getExtractDayFormatFromTimestampFieldSuffix(dayFormat) + ")"; // chiusura trim
  290.         }
  291.         else {
  292.             return super.getExtractDayFormatFromTimestampFieldSuffix(dayFormat);
  293.         }
  294.     }
  295.     
  296.     
  297.     
  298.     
  299.     
  300.     
  301.     
  302.     
  303.     
  304.     
  305.     @Override
  306.     public ISQLQueryObject addWhereIsEmptyCondition(String field) throws SQLQueryObjectException{
  307.         // In oracle le stringhe vuote equivalgono a null
  308.         return this.addWhereIsNullCondition(field);
  309.     }
  310.     
  311.     @Override
  312.     public ISQLQueryObject addWhereIsNotEmptyCondition(String field) throws SQLQueryObjectException{
  313.         // In oracle le stringhe vuote equivalgono a null
  314.         return this.addWhereIsNotNullCondition(field);
  315.     }
  316.     
  317.     
  318.     
  319.     
  320.     /**
  321.      * Crea una SQL Query con i dati dell'oggetto
  322.      * 
  323.      * @return SQL Query
  324.      */
  325.     @Override
  326.     public String createSQLQuery() throws SQLQueryObjectException{
  327.         return this.createSQLQuery(false);
  328.     }
  329.     private String createSQLQuery(boolean union) throws SQLQueryObjectException{
  330.         
  331.         this.precheckBuildQuery();
  332.         
  333.         StringBuilder bf = new StringBuilder();
  334.         
  335.         bf.append("SELECT ");
  336.         
  337.         // forzatura di indici
  338.         if( !(this.offset>=0 || this.limit>=0) ){
  339.             Iterator<String> itForceIndex = this.forceIndexTableNames.iterator();
  340.             while(itForceIndex.hasNext()){
  341.                 bf.append(" "+itForceIndex.next()+" ");
  342.             }
  343.         }
  344.         
  345.         if(this.isSelectDistinct())
  346.             bf.append(" DISTINCT ");
  347.         
  348.         // select field
  349.         addSQLQuerySelectField(bf);
  350.         
  351.         bf.append(getSQL(false,false,false,union));
  352.         
  353.         /**if( this.offset>=0 || this.limit>=0)
  354.         //  System.out.println("SQL ["+bf.toString()+"]");*/
  355.         
  356.         return bf.toString();
  357.     }
  358.     private void addSQLQuerySelectField(StringBuilder bf) {
  359.         if(this.fields.isEmpty()){
  360.             bf.append("*");
  361.         }else{
  362.             Iterator<String> it = this.fields.iterator();
  363.             boolean first = true;
  364.             while(it.hasNext()){
  365.                 if(!first)
  366.                     bf.append(",");
  367.                 else
  368.                     first = false;

  370.                 String field = it.next();
  371.                 /**if( this.offset>=0 || this.limit>=0){*/
  372.                 // Rilascio vincolo di order by in caso di limit impostato.
  373.                 // Il vincolo rimane per l'offset, per gestire le select annidate di qualche implementazioni come Oracle,SQLServer ...
  374.                 if( this.offset>=0 ){
  375.                     
  376.                     field = this.normalizeField(field, false);

  378.                 } 
  379.                 bf.append(field);
  380.             }
  381.         }
  382.     }
  383.     

  385.     /**
  386.      * Crea una SQL per una operazione di Delete con i dati dell'oggetto
  387.      * 
  388.      * @return SQL per una operazione di Delete
  389.      */
  390.     @Override
  391.     public String createSQLDeleteEngine() throws SQLQueryObjectException{
  392.         
  393.         StringBuilder bf = new StringBuilder();
  394.                 
  395.         bf.append("DELETE ");
  396.         
  397.         bf.append(getSQL(true,false,false,false));
  398.         return bf.toString();
  399.     }
  400.     
  401.     
  402.     /**
  403.      * @return SQL
  404.      * @throws SQLQueryObjectException
  405.      */
  406.     private String getSQL(boolean delete,boolean update,boolean conditions,boolean union) throws SQLQueryObjectException {
  407.         StringBuilder bf = new StringBuilder();
  408.         
  409.         if(this.selectForUpdate){
  410.             this.checkSelectForUpdate(update, delete, union);
  411.         }
  412.         
  413.         if(!update && !conditions){
  414.             // From
  415.             bf.append(SQLQueryObjectCore.FROM_SEPARATOR);
  416.             
  417.             
  418.             // Se e' presente Offset
  419.             /**if( (this.offset>=0 || this.limit>=0) && (delete==false)){*/
  420.             // Rilascio vincolo di order by in caso di limit impostato.
  421.             // Il vincolo rimane per l'offset, per gestire le select annidate di qualche implementazioni come Oracle,SQLServer ...
  422.             if( (this.offset>=0) && (!delete)){
  423.                 
  424.                 /**java.util.List<String> aliasOrderByDistinct = new java.util.ArrayList<>();*/
  425.                                 
  426.                 if(!this.isSelectDistinct()){
  427.                 
  428.                     bf.append(SQLQueryObjectCore.SELECT_SEPARATOR_CON_INIZIO_APERTURA);
  429.                     
  430.                     Iterator<String> itForceIndex = this.forceIndexTableNames.iterator();
  431.                     while(itForceIndex.hasNext()){
  432.                         bf.append(" "+itForceIndex.next()+" ");
  433.                     }
  434.                                     
  435.                     if(this.fields.isEmpty()){
  436.                         Iterator<String> it = this.tableNames.iterator();
  437.                         boolean first = true;
  438.                         while(it.hasNext()){
  439.                             if(!first)
  440.                                 bf.append(",");
  441.                             else
  442.                                 first = false;
  443.                             String t = it.next();
  444.                             bf.append(t+".*");
  445.                         }
  446.                     }else{
  447.                         Iterator<String> it = this.fields.iterator();
  448.                         boolean first = true;
  449.                         while(it.hasNext()){
  450.                             if(!first)
  451.                                 bf.append(",");
  452.                             else
  453.                                 first = false;
  454.                             String f = it.next();
  455.                             bf.append(f);
  456.                         }
  457.                     }
  458.                     
  459.                     
  460.                     bf.append(" , ROW_NUMBER() OVER ( ORDER BY ");
  461.                     
  462.                     // Condizione OrderBy
  463.                     if(this.orderBy.isEmpty()){
  464.                         throw new SQLQueryObjectException(SQLQueryObjectCore.CONDIZIONI_ORDER_BY_RICHESTE);
  465.                     }
  466.                     if(!this.orderBy.isEmpty()){
  467.                         Iterator<String> it = this.orderBy.iterator();
  468.                         boolean first = true;
  469.                         while(it.hasNext()){
  470.                             if(!first)
  471.                                 bf.append(",");
  472.                             else
  473.                                 first = false;
  474.                             String condizione = it.next();
  475.                             if(this.alias.containsKey(condizione)){
  476.                                 bf.append(this.alias.get(condizione));
  477.                             }else{
  478.                                 bf.append(condizione);
  479.                             }
  480.                             boolean sortTypeAsc = this.sortTypeAsc;
  481.                             if(this.orderBySortType.containsKey(condizione)){
  482.                                 sortTypeAsc = this.orderBySortType.get(condizione);
  483.                             }
  484.                             if(sortTypeAsc){
  485.                                 bf.append(SQLQueryObjectCore.ASC_SEPARATOR);
  486.                             }else{
  487.                                 bf.append(SQLQueryObjectCore.DESC_SEPARATOR);
  488.                             }
  489.                         }
  490.                     }
  491.                 
  492.                     bf.append(" ) AS rowNumber ");
  493.                     
  494.                 
  495.                     bf.append(SQLQueryObjectCore.FROM_SEPARATOR);
  496.                 
  497.                                 
  498.                     // Table dove effettuare la ricerca 'FromTable'
  499.                     if(this.tables.isEmpty()){
  500.                         throw new SQLQueryObjectException(SQLQueryObjectCore.TABELLA_RICERCA_FROM_NON_DEFINITA);
  501.                     }else{
  502.                         Iterator<String> it = this.tables.iterator();
  503.                         boolean first = true;
  504.                         while(it.hasNext()){
  505.                             if(!first)
  506.                                 bf.append(",");
  507.                             else
  508.                                 first = false;
  509.                             bf.append(it.next());
  510.                         }
  511.                     }
  512.                 
  513.                     // Condizioni di Where
  514.                     if(!this.conditions.isEmpty()){
  515.                     
  516.                         bf.append(SQLQueryObjectCore.WHERE_SEPARATOR);
  517.                         
  518.                         if(this.notBeforeConditions){
  519.                             bf.append(SQLQueryObjectCore.NOT_SEPARATOR_APERTURA);
  520.                         }
  521.                         
  522.                         for(int i=0; i<this.conditions.size(); i++){
  523.                             
  524.                             if(i>0){
  525.                                 if(this.andLogicOperator){
  526.                                     bf.append(SQLQueryObjectCore.AND_SEPARATOR);
  527.                                 }else{
  528.                                     bf.append(SQLQueryObjectCore.OR_SEPARATOR);
  529.                                 }
  530.                             }
  531.                             String cond = this.conditions.get(i);               
  532.                             bf.append(cond);
  533.                         }
  534.                         
  535.                         if(this.notBeforeConditions){
  536.                             bf.append(" )");
  537.                         }
  538.                     }
  539.                     
  540.                     // Condizione GroupBy
  541.                     if((!this.getGroupByConditions().isEmpty()) && (!delete)){
  542.                         bf.append(SQLQueryObjectCore.GROUP_BY_SEPARATOR);
  543.                         Iterator<String> it = this.getGroupByConditions().iterator();
  544.                         boolean first = true;
  545.                         while(it.hasNext()){
  546.                             if(!first)
  547.                                 bf.append(",");
  548.                             else
  549.                                 first = false;
  550.                             bf.append(it.next());
  551.                         }
  552.                     }
  553.                     
  554.                     // ForUpdate (Non si può utilizzarlo con offset o limit in oracle)
  555. /**                 if(this.selectForUpdate){
  556. //                      bf.append(" FOR UPDATE ");
  557. //                  }*/
  558.                 
  559.                 }else{
  560.                     
  561.                     bf.append(SQLQueryObjectCore.SELECT_SEPARATOR_CON_INIZIO_APERTURA);
  562.                     
  563.                     Iterator<String> itForceIndex = this.forceIndexTableNames.iterator();
  564.                     while(itForceIndex.hasNext()){
  565.                         bf.append(" "+itForceIndex.next()+" ");
  566.                     }
  567.                     
  568.                     if(this.fields.isEmpty()){
  569.                         Iterator<String> it = this.tableNames.iterator();
  570.                         boolean first = true;
  571.                         while(it.hasNext()){
  572.                             if(!first)
  573.                                 bf.append(",");
  574.                             else
  575.                                 first = false;
  576.                             String t = it.next();
  577.                             bf.append(t+".*");
  578.                         }
  579.                     }else{
  580.                         Iterator<String> it = this.fields.iterator();
  581.                         boolean first = true;
  582.                         while(it.hasNext()){
  583.                             if(!first)
  584.                                 bf.append(",");
  585.                             else
  586.                                 first = false;
  587.                             String field = it.next();
  588.                             
  589.                             field = this.normalizeField(field, false);
  590.                             
  591.                             bf.append(field);
  592.                         }
  593.                     }
  594.                     
  595.                     // Cerco inoltre se ci sono delle condizioni di ORDER BY, ed in tal caso le metto come Alias
  596.                     /** NON FUNZIONA
  597.                     int contatoreAlias = 0;
  598.                     if(this.orderBy.size()>0){
  599.                         Iterator<String> it = this.orderBy.iterator();
  600.                         while(it.hasNext()){
  601.                             String fieldOrder = it.next();
  602.                             contatoreAlias++;
  603.                             String a = "ALIASFIELD"+contatoreAlias;
  604.                             aliasOrderByDistinct.add(a);
  605.                             // In questa lista di select field inoltre aggiunto l'alias.
  606.                             if(this.fields.size()==0)
  607.                                 bf.append(a);
  608.                             else
  609.                                 bf.append(","+a);
  610.                             // Verra' aggiunto nelle select piu' interna.
  611.                             //this.fields.add(fieldOrder +" as "+a);
  612.                             this.fields.add(fieldOrder +this.getAliasFieldKeyword()+a);
  613.                         }
  614.                     }
  615.                     */
  616.                     
  617.                     bf.append(" , ROWNUM AS rowNumber");
  618.                 
  619.                     bf.append(SQLQueryObjectCore.FROM_SEPARATOR);
  620.                     
  621.                     bf.append(" ( SELECT DISTINCT ");
  622.                     
  623.                         if(this.fields.isEmpty()){
  624.                             bf.append("*");
  625.                         }else{
  626.                             Iterator<String> it = this.fields.iterator();
  627.                             boolean first = true;
  628.                             while(it.hasNext()){
  629.                                 if(!first)
  630.                                     bf.append(",");
  631.                                 else
  632.                                     first = false;
  633.                                 String f = it.next();
  634.                                 bf.append(f);
  635.                             }
  636.                         }
  637.                         
  638.                         bf.append(SQLQueryObjectCore.FROM_SEPARATOR);
  639.                     
  640.                         // Table dove effettuare la ricerca 'FromTable'
  641.                         if(this.tables.isEmpty()){
  642.                             throw new SQLQueryObjectException(SQLQueryObjectCore.TABELLA_RICERCA_FROM_NON_DEFINITA);
  643.                         }else{
  644.                             Iterator<String> it = this.tables.iterator();
  645.                             boolean first = true;
  646.                             while(it.hasNext()){
  647.                                 if(!first)
  648.                                     bf.append(",");
  649.                                 else
  650.                                     first = false;
  651.                                 bf.append(it.next());
  652.                             }
  653.                         }
  654.                     
  655.                         bf.append(" ");
  656.                         
  657.                         // Condizioni di Where
  658.                         if(!this.conditions.isEmpty()){
  659.                         
  660.                             bf.append(SQLQueryObjectCore.WHERE_SEPARATOR);
  661.                             
  662.                             if(this.notBeforeConditions){
  663.                                 bf.append(SQLQueryObjectCore.NOT_SEPARATOR_APERTURA);
  664.                             }
  665.                             
  666.                             for(int i=0; i<this.conditions.size(); i++){
  667.                                 
  668.                                 if(i>0){
  669.                                     if(this.andLogicOperator){
  670.                                         bf.append(SQLQueryObjectCore.AND_SEPARATOR);
  671.                                     }else{
  672.                                         bf.append(SQLQueryObjectCore.OR_SEPARATOR);
  673.                                     }
  674.                                 }
  675.                                 String cond = this.conditions.get(i);               
  676.                                 bf.append(cond);
  677.                             }
  678.                             
  679.                             if(this.notBeforeConditions){
  680.                                 bf.append(" )");
  681.                             }
  682.                         }
  683.                         
  684.                         // Condizione GroupBy
  685.                         if((!this.getGroupByConditions().isEmpty()) && (!delete)){
  686.                             bf.append(SQLQueryObjectCore.GROUP_BY_SEPARATOR);
  687.                             Iterator<String> it = this.getGroupByConditions().iterator();
  688.                             boolean first = true;
  689.                             while(it.hasNext()){
  690.                                 if(!first)
  691.                                     bf.append(",");
  692.                                 else
  693.                                     first = false;
  694.                                 bf.append(it.next());
  695.                             }
  696.                         }
  697.                         
  698.                         // Condizione OrderBy
  699.                         if(this.orderBy.isEmpty()){
  700.                             throw new SQLQueryObjectException(SQLQueryObjectCore.CONDIZIONI_ORDER_BY_RICHESTE);
  701.                         }
  702.                         if(!this.orderBy.isEmpty()){
  703.                             bf.append(SQLQueryObjectCore.ORDER_BY_SEPARATOR);
  704.                             Iterator<String> it = this.orderBy.iterator();
  705.                             boolean first = true;
  706.                             while(it.hasNext()){
  707.                                 String column = it.next();
  708.                                 if(!first)
  709.                                     bf.append(",");
  710.                                 else
  711.                                     first = false;
  712.                                 bf.append(column);
  713.                                 boolean sortTypeAsc = this.sortTypeAsc;
  714.                                 if(this.orderBySortType.containsKey(column)){
  715.                                     sortTypeAsc = this.orderBySortType.get(column);
  716.                                 }
  717.                                 if(sortTypeAsc){
  718.                                     bf.append(SQLQueryObjectCore.ASC_SEPARATOR);
  719.                                 }else{
  720.                                     bf.append(SQLQueryObjectCore.DESC_SEPARATOR);
  721.                                 }
  722.                             }
  723.                         }
  724.                         
  725.                     bf.append(" ) ");
  726.                     
  727.                 }
  728.                 
  729.                 bf.append(" ) WHERE ( ");
  730.                 if(this.offset>=0){
  731.                     bf.append(" rowNumber > ");
  732.                     bf.append(this.offset);
  733.                 }
  734.                 if(this.limit>=0){
  735.                     if(this.offset>=0)
  736.                         bf.append(" AND");
  737.                     bf.append(" rowNumber <=  ");
  738.                     if(this.offset>=0)
  739.                         bf.append(this.offset+this.limit);
  740.                     else
  741.                         bf.append(this.limit);
  742.                 }
  743.                 bf.append(" )");
  744.                 
  745.                 
  746.                 // ORDER BY FINALE
  747.                 if(!union &&
  748.                     (!this.orderBy.isEmpty())
  749.                     ){
  750.                     bf.append(SQLQueryObjectCore.ORDER_BY_SEPARATOR);
  751.                     Iterator<String> it = this.orderBy.iterator();
  752.                     boolean first = true;
  753.                     while(it.hasNext()){
  754.                         if(!first)
  755.                             bf.append(",");
  756.                         else
  757.                             first = false;
  758.                         String originalField = it.next();
  759.                         
  760.                         String field = this.normalizeField(originalField);
  761.                         
  762.                         bf.append(field);
  763.                         
  764.                         boolean sortTypeAsc = this.sortTypeAsc;
  765.                         if(this.orderBySortType.containsKey(originalField)){
  766.                             sortTypeAsc = this.orderBySortType.get(originalField);
  767.                         }
  768.                         if(sortTypeAsc){
  769.                             bf.append(SQLQueryObjectCore.ASC_SEPARATOR);
  770.                         }else{
  771.                             bf.append(SQLQueryObjectCore.DESC_SEPARATOR);
  772.                         }
  773.                     }
  774.                 }
  775.                 
  776.                 /** 
  777.                  * OLD ALIAS
  778.                 if(aliasOrderByDistinct.size()>0){
  779.                     bf.append(SQLQueryObjectCore.ORDER_BY_SEPARATOR);
  780.                     Iterator<String> it = aliasOrderByDistinct.iterator();
  781.                     boolean first = true;
  782.                     while(it.hasNext()){
  783.                         if(!first)
  784.                             bf.append(",");
  785.                         else
  786.                             first = false;
  787.                         bf.append(it.next());
  788.                     }
  789.                     if(this.sortTypeAsc){
  790.                         bf.append(SQLQueryObjectCore.ASC_SEPARATOR);
  791.                     }else{
  792.                         bf.append(SQLQueryObjectCore.DESC_SEPARATOR);
  793.                     }
  794.                 }
  795.                 */
  796.                 
  797.             }else{
  798.                 
  799.                 // Offset non presente
  800.                 
  801.                 // Table dove effettuare la ricerca 'FromTable'
  802.                 if(this.tables.isEmpty()){
  803.                     throw new SQLQueryObjectException(SQLQueryObjectCore.TABELLA_RICERCA_FROM_NON_DEFINITA);
  804.                 }else{
  805.                     
  806.                     if(delete && this.tables.size()>2)
  807.                         throw new SQLQueryObjectException("Non e' possibile effettuare una delete con piu' di una tabella alla volta");
  808.                     
  809.                     Iterator<String> it = this.tables.iterator();
  810.                     boolean first = true;
  811.                     while(it.hasNext()){
  812.                         if(!first)
  813.                             bf.append(",");
  814.                         else
  815.                             first = false;
  816.                         bf.append(it.next());
  817.                     }
  818.                 }
  819.                 
  820.                 // Condizioni di Where
  821.                 if(!this.conditions.isEmpty()){
  822.                     bf.append(SQLQueryObjectCore.WHERE_SEPARATOR);
  823.                     
  824.                     if(this.notBeforeConditions){
  825.                         bf.append("NOT (");
  826.                     }
  827.                     
  828.                     for(int i=0; i<this.conditions.size(); i++){
  829.                         if(i>0){
  830.                             if(this.andLogicOperator){
  831.                                 bf.append(SQLQueryObjectCore.AND_SEPARATOR);
  832.                             }else{
  833.                                 bf.append(SQLQueryObjectCore.OR_SEPARATOR);
  834.                             }
  835.                         }
  836.                         bf.append(this.conditions.get(i));
  837.                     }
  838.                     
  839.                     if(this.notBeforeConditions){
  840.                         bf.append(")");
  841.                     }
  842.                     
  843.                 }
  844.                         
  845.                 // LIMIT
  846.                 if(this.limit>=0){
  847.                     if(this.conditions.isEmpty()){
  848.                         bf.append(SQLQueryObjectCore.WHERE_SEPARATOR);
  849.                     }else{
  850.                         bf.append(SQLQueryObjectCore.AND_SEPARATOR);
  851.                     }
  852.                     bf.append(" ( rownum <= ");
  853.                     bf.append(this.limit);
  854.                     bf.append(" ) ");
  855.                 }
  856.                 
  857.                 // Condizione GroupBy
  858.                 if((!this.getGroupByConditions().isEmpty()) && (!delete)){
  859.                     bf.append(SQLQueryObjectCore.GROUP_BY_SEPARATOR);
  860.                     Iterator<String> it = this.getGroupByConditions().iterator();
  861.                     boolean first = true;
  862.                     while(it.hasNext()){
  863.                         if(!first)
  864.                             bf.append(",");
  865.                         else
  866.                             first = false;
  867.                         bf.append(it.next());
  868.                     }
  869.                 }
  870.             
  871.                 // Condizione OrderBy
  872.                 if(!union &&
  873.                     ((!this.orderBy.isEmpty()) && (!delete))
  874.                     ){
  875.                     bf.append(SQLQueryObjectCore.ORDER_BY_SEPARATOR);
  876.                     Iterator<String> it = this.orderBy.iterator();
  877.                     boolean first = true;
  878.                     while(it.hasNext()){
  879.                         String column = it.next();
  880.                         if(!first)
  881.                             bf.append(",");
  882.                         else
  883.                             first = false;
  884.                         bf.append(column);
  885.                         boolean sortTypeAsc = this.sortTypeAsc;
  886.                         if(this.orderBySortType.containsKey(column)){
  887.                             sortTypeAsc = this.orderBySortType.get(column);
  888.                         }
  889.                         if(sortTypeAsc){
  890.                             bf.append(SQLQueryObjectCore.ASC_SEPARATOR);
  891.                         }else{
  892.                             bf.append(SQLQueryObjectCore.DESC_SEPARATOR);
  893.                         }
  894.                     }
  895.                 }
  896.                 
  897.                 // ForUpdate
  898.                 if(this.selectForUpdate){
  899.                     bf.append(" FOR UPDATE ");
  900.                 }
  901.             }
  902.             
  903.         }else{
  904.             
  905.             // UPDATE, conditions
  906.             
  907.             // Condizioni di Where
  908.             if(!this.conditions.isEmpty()){
  909.                 
  910.                 if(!conditions)
  911.                     bf.append(SQLQueryObjectCore.WHERE_SEPARATOR);
  912.                 
  913.                 if(this.notBeforeConditions){
  914.                     bf.append("NOT (");
  915.                 }
  916.                 
  917.                 for(int i=0; i<this.conditions.size(); i++){
  918.                     if(i>0){
  919.                         if(this.andLogicOperator){
  920.                             bf.append(SQLQueryObjectCore.AND_SEPARATOR);
  921.                         }else{
  922.                             bf.append(SQLQueryObjectCore.OR_SEPARATOR);
  923.                         }
  924.                     }
  925.                     bf.append(this.conditions.get(i));
  926.                 }
  927.                 
  928.                 if(this.notBeforeConditions){
  929.                     bf.append(")");
  930.                 }
  931.                 
  932.             }
  933.             
  934.             // Non genero per le condizioni, per update viene sollevata eccezione prima
  935.             // ForUpdate
  936. /**         if(this.selectForUpdate){
  937. //              bf.append(" FOR UPDATE ");
  938. //          }*/
  939.         }
  940.         
  941.         return bf.toString();
  942.     }
  943.     
  944.     /**
  945.      * Crea la stringa SQL per l'unione dei parametri presi in sqlQueryObject
  946.      * Il booleano 'unionAll' indica se i vari parametri devono essere uniti con 'UNION'  o con 'UNION ALL'
  947.      * 
  948.      * In caso nell'oggetto viene impostato il LIMIT o OFFSET, questo viene utilizzato per effettuare LIMIT e/o OFFSET dell'unione
  949.      * 
  950.      * In caso l'ORDER by viene impostato nell'oggetto, questo viene utilizzato per effettuare ORDER BY dell'unione
  951.      * 
  952.      * 
  953.      * Sintassi OracleSQL:
  954.      * 
  955.      * SELECT * from
  956.      * (
  957.      * (  SELECT fields... FROM tabella WHERE conditions  )
  958.      * UNION [ALL]
  959.      * (  SELECT fields... FROM tabella WHERE conditions  )
  960.      * )
  961.      * WHERE ROWNUM&lt;=LIMIT+OFFSET AND ROWNUM&gt;OFFSET
  962.      * ORDER BY gdo,tipo_fruitore,fruitore,tipo_erogatore,erogatore,tipo_servizio,servizio DESC  
  963.      * 
  964.      * 
  965.      * @param unionAll
  966.      * @param sqlQueryObject
  967.      * @return stringa SQL per l'unione dei parametri presi in sqlQueryObject
  968.      * @throws SQLQueryObjectException
  969.      */
  970.     @Override
  971.     public String createSQLUnion(boolean unionAll,ISQLQueryObject... sqlQueryObject) throws SQLQueryObjectException{
  972.                 
  973.         // Controllo parametro su cui effettuare la UNION
  974.         this.checkUnionField(false,sqlQueryObject);
  975.         
  976.         if(this.selectForUpdate){
  977.             this.checkSelectForUpdate(false, false, true);
  978.         }
  979.         
  980.         StringBuilder bf = new StringBuilder();
  981.         
  982.         bf.append("SELECT ");
  983.         
  984. //      // Non ha senso, la union fa gia la distinct, a meno di usare la unionAll ma in quel caso non si vuole la distinct
  985. /**     // if(this.isSelectDistinct())
  986. //      //  bf.append(" DISTINCT ");*/
  987.         
  988.         
  989.         if( this.offset<0 ){
  990.             
  991.             Iterator<String> itForceIndex = this.forceIndexTableNames.iterator();
  992.             while(itForceIndex.hasNext()){
  993.                 bf.append(" "+itForceIndex.next()+" ");
  994.             }
  995.             
  996.             if(this.fields.isEmpty()){
  997.                 bf.append("* ");
  998.             }else{
  999.                 Iterator<String> it = this.fields.iterator();
  1000.                 boolean first = true;
  1001.                 while(it.hasNext()){
  1002.                     if(!first)
  1003.                         bf.append(",");
  1004.                     else
  1005.                         first = false;
  1006.                     String f = it.next();
  1007.                     bf.append(f);
  1008.                 }
  1009.                 bf.append(" ");
  1010.             }
  1011.     
  1012.         }
  1013.         else{
  1014.             bf.append("* ");
  1015.         }
  1016.     
  1017.         bf.append(SQLQueryObjectCore.FROM_SEPARATOR);
  1018.         
  1019.         // Se e' presente Offset
  1020.         /**if( (this.offset>=0 || this.limit>=0) ){*/
  1021.         // Rilascio vincolo di order by in caso di limit impostato.
  1022.         // Il vincolo rimane per l'offset, per gestire le select annidate di qualche implementazioni come Oracle,SQLServer ...
  1023.         if( this.offset>=0 ){
  1024.             
  1025.             bf.append(SQLQueryObjectCore.SELECT_SEPARATOR_CON_INIZIO_APERTURA);
  1026.             
  1027.             Iterator<String> itForceIndex = this.forceIndexTableNames.iterator();
  1028.             while(itForceIndex.hasNext()){
  1029.                 bf.append(" "+itForceIndex.next()+" ");
  1030.             }
  1031.             
  1032.             if(this.fields.isEmpty()){
  1033.                 Iterator<String> it = this.tableNames.iterator();
  1034.                 boolean first = true;
  1035.                 while(it.hasNext()){
  1036.                     if(!first)
  1037.                         bf.append(",");
  1038.                     else
  1039.                         first = false;
  1040.                     String t = it.next();
  1041.                     bf.append(t+".*");
  1042.                 }
  1043.             }else{
  1044.                 Iterator<String> it = this.fields.iterator();
  1045.                 boolean first = true;
  1046.                 while(it.hasNext()){
  1047.                     if(!first)
  1048.                         bf.append(",");
  1049.                     else
  1050.                         first = false;
  1051.                     String f = it.next();
  1052.                     bf.append(f);
  1053.                 }
  1054.             }
  1055.             
  1056.             bf.append(" , ROW_NUMBER() OVER ( ORDER BY ");
  1057.             
  1058.             // Condizione OrderBy
  1059.             if(this.orderBy.isEmpty()){
  1060.                 throw new SQLQueryObjectException(SQLQueryObjectCore.CONDIZIONI_ORDER_BY_RICHESTE);
  1061.             }
  1062.             if(!this.orderBy.isEmpty()){
  1063.                 Iterator<String> it = this.orderBy.iterator();
  1064.                 boolean first = true;
  1065.                 while(it.hasNext()){
  1066.                     if(!first)
  1067.                         bf.append(",");
  1068.                     else
  1069.                         first = false;
  1070.                     String condizione = it.next();
  1071.                     if(this.alias.containsKey(condizione)){
  1072.                         bf.append(this.alias.get(condizione));
  1073.                     }else{
  1074.                         bf.append(condizione);
  1075.                     }
  1076.                     boolean sortTypeAsc = this.sortTypeAsc;
  1077.                     if(this.orderBySortType.containsKey(condizione)){
  1078.                         sortTypeAsc = this.orderBySortType.get(condizione);
  1079.                     }
  1080.                     if(sortTypeAsc){
  1081.                         bf.append(SQLQueryObjectCore.ASC_SEPARATOR);
  1082.                     }else{
  1083.                         bf.append(SQLQueryObjectCore.DESC_SEPARATOR);
  1084.                     }
  1085.                 }
  1086.             }
  1087.             
  1088.             bf.append(" ) AS rowNumber ");
  1089.             
  1090.             
  1091.             // Table dove effettuare la ricerca 'FromTable'
  1092.             bf.append(SQLQueryObjectCore.FROM_SEPARATOR_APERTURA);
  1093.             
  1094.             for(int i=0; i<sqlQueryObject.length; i++){
  1095.                 
  1096.                 if(((OracleQueryObject)sqlQueryObject[i]).selectForUpdate){
  1097.                     try{
  1098.                         ((OracleQueryObject)sqlQueryObject[i]).checkSelectForUpdate(false, false, true);
  1099.                     }catch(Exception e){
  1100.                         throw new SQLQueryObjectException("Parametro SqlQueryObject["+i+"] non valido: "+e.getMessage());
  1101.                     }
  1102.                 }
  1103.                 
  1104.                 if(i>0){
  1105.                     bf.append(" UNION ");
  1106.                     if(unionAll){
  1107.                         bf.append(" ALL ");
  1108.                     }
  1109.                 }
  1110.                 
  1111.                 bf.append("( ");
  1112.                 
  1113.                 bf.append(((OracleQueryObject)sqlQueryObject[i]).createSQLQuery(true));
  1114.                 
  1115.                 bf.append(") ");
  1116.             }
  1117.             
  1118.             bf.append(" ) ");
  1119.             
  1120.             // Condizioni di Where
  1121.             if(!this.conditions.isEmpty()){
  1122.             
  1123.                 bf.append(SQLQueryObjectCore.WHERE_SEPARATOR);
  1124.                 
  1125.                 if(this.notBeforeConditions){
  1126.                     bf.append(SQLQueryObjectCore.NOT_SEPARATOR_APERTURA);
  1127.                 }
  1128.                 
  1129.                 for(int i=0; i<this.conditions.size(); i++){
  1130.                     
  1131.                     if(i>0){
  1132.                         if(this.andLogicOperator){
  1133.                             bf.append(SQLQueryObjectCore.AND_SEPARATOR);
  1134.                         }else{
  1135.                             bf.append(SQLQueryObjectCore.OR_SEPARATOR);
  1136.                         }
  1137.                     }
  1138.                     String cond = this.conditions.get(i);
  1139.                     bf.append(cond);
  1140.                 }
  1141.                 
  1142.                 if(this.notBeforeConditions){
  1143.                     bf.append(" )");
  1144.                 }
  1145.             }
  1146.             
  1147.             // Condizione GroupBy
  1148.             if((!this.getGroupByConditions().isEmpty())){
  1149.                 bf.append(SQLQueryObjectCore.GROUP_BY_SEPARATOR);
  1150.                 Iterator<String> it = this.getGroupByConditions().iterator();
  1151.                 boolean first = true;
  1152.                 while(it.hasNext()){
  1153.                     if(!first)
  1154.                         bf.append(",");
  1155.                     else
  1156.                         first = false;
  1157.                     bf.append(it.next());
  1158.                 }
  1159.             }
  1160.             
  1161.             bf.append(" ) WHERE ( ");
  1162.             if(this.offset>=0){
  1163.                 bf.append(" rowNumber > ");
  1164.                 bf.append(this.offset);
  1165.             }
  1166.             if(this.limit>=0){
  1167.                 if(this.offset>=0)
  1168.                     bf.append(" AND");
  1169.                 bf.append(" rowNumber <=  ");
  1170.                 if(this.offset>=0)
  1171.                     bf.append(this.offset+this.limit);
  1172.                 else
  1173.                     bf.append(this.limit);
  1174.             }
  1175.             bf.append(" )");
  1176.         
  1177.         
  1178.         }else{
  1179.             
  1180.             // no offset
  1181.             
  1182.             bf.append(" ( ");
  1183.             
  1184.             for(int i=0; i<sqlQueryObject.length; i++){
  1185.                 
  1186.                 if(((OracleQueryObject)sqlQueryObject[i]).selectForUpdate){
  1187.                     try{
  1188.                         ((OracleQueryObject)sqlQueryObject[i]).checkSelectForUpdate(false, false, true);
  1189.                     }catch(Exception e){
  1190.                         throw new SQLQueryObjectException("Parametro SqlQueryObject["+i+"] non valido: "+e.getMessage());
  1191.                     }
  1192.                 }
  1193.                 
  1194.                 if(i>0){
  1195.                     bf.append(" UNION ");
  1196.                     if(unionAll){
  1197.                         bf.append(" ALL ");
  1198.                     }
  1199.                 }
  1200.                 
  1201.                 bf.append("( ");
  1202.                 
  1203.                 bf.append(((OracleQueryObject)sqlQueryObject[i]).createSQLQuery(true));
  1204.                 
  1205.                 bf.append(") ");
  1206.             }
  1207.             
  1208.             bf.append(") ");

  1210.             // LIMIT
  1211.             if(this.limit>=0){
  1212.                 bf.append(SQLQueryObjectCore.WHERE_SEPARATOR);
  1213.                 bf.append(" ( rownum <= ");
  1214.                 bf.append(this.limit);
  1215.                 bf.append(" ) ");
  1216.             }   
  1217.             
  1218.             // Condizione GroupBy
  1219.             if((!this.getGroupByConditions().isEmpty())){
  1220.                 bf.append(SQLQueryObjectCore.GROUP_BY_SEPARATOR);
  1221.                 Iterator<String> it = this.getGroupByConditions().iterator();
  1222.                 boolean first = true;
  1223.                 while(it.hasNext()){
  1224.                     if(!first)
  1225.                         bf.append(",");
  1226.                     else
  1227.                         first = false;
  1228.                     bf.append(it.next());
  1229.                 }
  1230.             }
  1231.             
  1232.             // Condizione OrderBy
  1233.             if(!this.orderBy.isEmpty()){
  1234.                 bf.append(SQLQueryObjectCore.ORDER_BY_SEPARATOR);
  1235.                 Iterator<String> it = this.orderBy.iterator();
  1236.                 boolean first = true;
  1237.                 while(it.hasNext()){
  1238.                     String column = it.next();
  1239.                     if(!first)
  1240.                         bf.append(",");
  1241.                     else
  1242.                         first = false;
  1243.                     bf.append(column);
  1244.                     boolean sortTypeAsc = this.sortTypeAsc;
  1245.                     if(this.orderBySortType.containsKey(column)){
  1246.                         sortTypeAsc = this.orderBySortType.get(column);
  1247.                     }
  1248.                     if(sortTypeAsc){
  1249.                         bf.append(SQLQueryObjectCore.ASC_SEPARATOR);
  1250.                     }else{
  1251.                         bf.append(SQLQueryObjectCore.DESC_SEPARATOR);
  1252.                     }
  1253.                 }
  1254.             }
  1255.         }
  1256.         
  1257. /**     bf.append(" ) ");*/
  1258.         
  1259.         return bf.toString();
  1260.     }
  1261.     
  1262.     
  1263.     /**
  1264.      * Crea la stringa SQL per l'unione dei parametri presi in sqlQueryObject (viene effettuato il count)
  1265.      * Il booleano 'unionAll' indica se i vari parametri devono essere uniti con 'UNION'  o con 'UNION ALL'
  1266.      * 
  1267.      * Sintassi OracleSQL:
  1268.      * 
  1269.      * select count(*) as aliasCount FROM (
  1270.      * 
  1271.      * (  SELECT fields... FROM tabella WHERE conditions  )
  1272.      * UNION [ALL]
  1273.      * (  SELECT fields... FROM tabella WHERE conditions  )
  1274.      * 
  1275.      * )
  1276.      * 
  1277.      * @param unionAll
  1278.      * @param sqlQueryObject
  1279.      * @return stringa SQL per l'unione dei parametri presi in sqlQueryObject (viene effettuato il count)
  1280.      * @throws SQLQueryObjectException
  1281.      */
  1282.     @Override
  1283.     public String createSQLUnionCount(boolean unionAll,String aliasCount,ISQLQueryObject... sqlQueryObject) throws SQLQueryObjectException{
  1284.         
  1285.         // Controllo parametro su cui effettuare la UNION
  1286.         this.checkUnionField(true,sqlQueryObject);
  1287.         
  1288.         if(aliasCount==null){
  1289.             throw new SQLQueryObjectException("Alias per il count non definito");
  1290.         }
  1291.         
  1292.         StringBuilder bf = new StringBuilder();
  1293.         
  1294.         bf.append("SELECT count(*) "+this.getDefaultAliasFieldKeyword()+" ");
  1295.         bf.append(aliasCount);
  1296.         bf.append(SQLQueryObjectCore.FROM_SEPARATOR_APERTURA);
  1297.         
  1298.         bf.append( this.createSQLUnion(unionAll, sqlQueryObject) );
  1299.         
  1300.         bf.append(") ");
  1301.         
  1302.         return bf.toString();
  1303.         
  1304.     }
  1305.     
  1306.     
  1307.     
  1308.     /**
  1309.      * Crea una SQL per una operazione di Update con i dati dell'oggetto
  1310.      * 
  1311.      * @return SQL per una operazione di Update
  1312.      */
  1313.     @Override
  1314.     public String createSQLUpdateEngine() throws SQLQueryObjectException{
  1315.         
  1316.         StringBuilder bf = new StringBuilder();
  1317.         bf.append("UPDATE ");
  1318.         bf.append(this.updateTable);
  1319.         bf.append(" SET ");
  1320.         for(int i=0; i<this.updateFieldsName.size(); i++){
  1321.             if(i>0)
  1322.                 bf.append(" , ");
  1323.             bf.append(this.updateFieldsName.get(i));
  1324.             bf.append(" = ");
  1325.             bf.append(this.updateFieldsValue.get(i));
  1326.         }
  1327.         bf.append(getSQL(false,true,false,false));
  1328.         return bf.toString();
  1329.     }

  1331.     
  1332.     
  1333.     
  1334.     
  1335.     
  1336.     
  1337.     /* ---------------- WHERE CONDITIONS ------------------ */
  1338.     
  1339.     /**
  1340.      * Crea le condizioni presenti senza anteporre il comando (INSERT,CREATE,UPDATE), le tabelle interessate e il 'WHERE'
  1341.      * 
  1342.      * @return SQL Query
  1343.      */
  1344.     @Override
  1345.     public String createSQLConditionsEngine() throws SQLQueryObjectException{
  1346.         
  1347.         StringBuilder bf = new StringBuilder();
  1348.         bf.append(getSQL(false,false,true,false));
  1349.         return bf.toString();
  1350.     }
  1351.     
  1352.     
  1353.     
  1354. }
Created with JaCoCo 0.8.8.202204050719