DB2QueryObject.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.  */

  21. package org.openspcoop2.utils.sql;

  23. import java.text.SimpleDateFormat;
  24. import java.util.Date;
  25. import java.util.Iterator;

  27. import org.openspcoop2.utils.TipiDatabase;
  28. import org.openspcoop2.utils.date.DateUtils;

  30. /**
  31.  * SQLServerQueryObject
  32.  * 
  33.  *
  34.  * @author Poli Andrea (apoli@link.it)
  35.  * @author $Author$
  36.  * @version $Rev$, $Date$
  37.  */
  38. public class DB2QueryObject extends SQLQueryObjectCore {

  40.     public DB2QueryObject(TipiDatabase tipoDatabase) {
  41.         super(tipoDatabase);
  42.     }
  43.     
  44.     
  45.     @Override
  46.     protected String getPrefixCastValue(CastColumnType type, int length) {
  47.         switch (type) {
  48.         case INT:
  49.         case LONG:
  50.         case STRING:
  51.         case TIMESTAMP:
  52.             return "CAST( ";
  53.         case NONE:
  54.             return "";
  55.         }
  56.         return "";
  57.     }
  58.     @Override
  59.     protected String getSuffixCastValue(CastColumnType type, int length) {
  60.         StringBuilder sb = new StringBuilder();
  61.         sb.append(" AS ");
  62.         switch (type) {
  63.         case INT:
  64.             sb.append("INT");
  65.             break;
  66.         case LONG:
  67.             sb.append("BIGINT");
  68.             break;
  69.         case STRING:
  70.             sb.append("VARCHAR");
  71.             break;
  72.         case TIMESTAMP:
  73.             sb.append("TIMESTAMP");
  74.             break;
  75.         case NONE:
  76.             return "";
  77.         }
  78.         sb.append(")");
  79.         return sb.toString();
  80.     }
  81.     
  82.     

  84.     
  85.     /**
  86.      * Ritorna una costante  di tipo 'timestamp'
  87.      * 
  88.      * @param date Costante
  89.      */
  90.     @Override
  91.     public String getSelectTimestampConstantField(Date date) throws SQLQueryObjectException{
  92.         SimpleDateFormat sqlDateformat = DateUtils.getDefaultDateTimeFormatter("yyyy-MM-dd HH:mm:ss.SSS");
  93.         return "TIMESTAMP('"+sqlDateformat.format(date)+"', 'YYYY-MM-DD HH24:MI:SS.FF3')";
  94.     }
  95.     
  96.     
  97.     
  98.     @Override
  99.     public String getUnixTimestampConversion(String column){
  100.         return "((((CAST (DAYS("+column+"-CURRENT_TIMEZONE) - DAYS('1970-01-01') AS BIGINT)*86400)+MIDNIGHT_SECONDS("+
  101.                 column+"-CURRENT_TIMEZONE))*1000)+(MICROSECOND("+
  102.                 column+")/1000))";
  103.     }
  104.     
  105.     @Override
  106.     public String getDiffUnixTimestamp(String columnMax,String columnMin){
  107.         return "( "+getUnixTimestampConversion(columnMax)+" - "+getUnixTimestampConversion(columnMin)+" )";
  108.     }
  109.     
  110.     
  111.     


  114.     @Override
  115.     public ISQLQueryObject addSelectAvgTimestampField(String field,
  116.             String alias) throws SQLQueryObjectException {
  117.         if(field==null)
  118.             throw new SQLQueryObjectException(SQLQueryObjectCore.FIELD_DEVE_ESSERE_DIVERSO_NULL);
  119.         // Trasformo in UNIX_TIMESTAMP
  120.         String fieldSQL = "avg("+this.getUnixTimestampConversion(field)+")";
  121.         if(alias != null){
  122.             /**fieldSQL = fieldSQL + " as "+alias;*/
  123.             fieldSQL = fieldSQL + this.getDefaultAliasFieldKeyword() + alias;
  124.         }
  125.         this.engineAddSelectField(null,fieldSQL,null,false,true);
  126.         this.fieldNames.add(alias);
  127.         return this;
  128.     }


  131.     @Override
  132.     public ISQLQueryObject addSelectMaxTimestampField(String field, String alias)
  133.             throws SQLQueryObjectException {
  134.         if(field==null)
  135.             throw new SQLQueryObjectException(SQLQueryObjectCore.FIELD_DEVE_ESSERE_DIVERSO_NULL);
  136.         // Trasformo in UNIX_TIMESTAMP
  137.         String fieldSQL = "max("+this.getUnixTimestampConversion(field)+")";
  138.         if(alias != null){
  139.             /**fieldSQL = fieldSQL + " as "+alias;*/
  140.             fieldSQL = fieldSQL + this.getDefaultAliasFieldKeyword() + alias;
  141.         }
  142.         this.engineAddSelectField(null,fieldSQL,null,false,true);
  143.         this.fieldNames.add(alias);
  144.         return this;
  145.     }


  148.     @Override
  149.     public ISQLQueryObject addSelectMinTimestampField(String field, String alias)
  150.             throws SQLQueryObjectException {
  151.         if(field==null)
  152.             throw new SQLQueryObjectException(SQLQueryObjectCore.FIELD_DEVE_ESSERE_DIVERSO_NULL);
  153.         // Trasformo in UNIX_TIMESTAMP
  154.         String fieldSQL = "min("+this.getUnixTimestampConversion(field)+")";
  155.         if(alias != null){
  156.             /**fieldSQL = fieldSQL + " as "+alias;*/
  157.             fieldSQL = fieldSQL + this.getDefaultAliasFieldKeyword() + alias;
  158.         }
  159.         this.engineAddSelectField(null,fieldSQL,null,false,true);
  160.         this.fieldNames.add(alias);
  161.         return this;
  162.     }


  165.     @Override
  166.     public ISQLQueryObject addSelectSumTimestampField(String field, String alias)
  167.             throws SQLQueryObjectException {
  168.         if(field==null)
  169.             throw new SQLQueryObjectException(SQLQueryObjectCore.FIELD_DEVE_ESSERE_DIVERSO_NULL);
  170.         // Trasformo in UNIX_TIMESTAMP
  171.         String fieldSQL = "sum("+this.getUnixTimestampConversion(field)+")";
  172.         if(alias != null){
  173.             /**fieldSQL = fieldSQL + " as "+alias;*/
  174.             fieldSQL = fieldSQL + this.getDefaultAliasFieldKeyword() + alias;
  175.         }
  176.         this.engineAddSelectField(null,fieldSQL,null,false,true);
  177.         this.fieldNames.add(alias);
  178.         return this;
  179.     }





  185.     @Override
  186.     public ISQLQueryObject addFromTable(ISQLQueryObject subSelect)
  187.             throws SQLQueryObjectException {
  188.         StringBuilder bf = new StringBuilder();
  189.         bf.append(" ( ");
  190.         bf.append(subSelect.createSQLQuery());
  191.         bf.append(" ) ");
  192.         // Devo forzare l'utilizzo di un alias su una sottoselct dentro il FROM 
  193.         // Genero Tre caratteri alafabetici casuali per dare un alias del tipo "tabellaXXX"
  194.         StringBuilder subselectalias = new StringBuilder();
  195.         subselectalias.append("tabella");
  196.         int rnd; 
  197.         char base;
  198.         for (int count=0 ; count < 3; count++ ){
  199.             rnd = (SQLQueryObjectCore.getRandom().nextInt(52) );
  200.             base = (rnd < 26) ? 'A' : 'a';
  201.             subselectalias.append((char) (base + rnd % 26));            
  202.         }
  203.         this.addFromTable(bf.toString(),subselectalias.toString());
  204.         return this;
  205.     }



  209.     @Override
  210.     protected EscapeSQLConfiguration getEscapeSQLConfiguration(){
  211.         
  212.         EscapeSQLConfiguration config = new EscapeSQLConfiguration();
  213.         config.addCharacter('_');
  214.         config.addCharacter('%');
  215.         config.addCharacter('\\');
  216.         config.setUseEscapeClausole(true);
  217.         config.setEscape('\\');
  218.         
  219.         // special
  220.         config.addCharacterWithOtherEscapeChar('\'','\'');
  221.         
  222.         return config;
  223.     }


  226.     
  227.     
  228.     
  229.     
  230.     
  231.     
  232.     
  233.     private static final String DAY_FORMAT_FULL_DAY_NAME = "%A";
  234.     private static final String DAY_FORMAT_SHORT_DAY_NAME = "%a";
  235.     
  236.     private SQLQueryObjectException newSQLQueryObjectExceptionDayFormatEnum(DayFormatEnum dayFormat) {
  237.         return new SQLQueryObjectException("DayFormatEnum '"+dayFormat+"' unknown");
  238.     }
  239.     @Override
  240.     protected String getDayFormat(DayFormatEnum dayFormat) throws SQLQueryObjectException {
  241.         switch (dayFormat) {
  242.         case FULL_DAY_NAME:
  243.             return DAY_FORMAT_FULL_DAY_NAME;
  244.         case SHORT_DAY_NAME:
  245.             return DAY_FORMAT_SHORT_DAY_NAME;
  246.         default:
  247.         }
  248.         throw newSQLQueryObjectExceptionDayFormatEnum(dayFormat);
  249.     }
  250.     @Override
  251.     public String getExtractDayFormatFromTimestampFieldPrefix(DayFormatEnum dayFormat) throws SQLQueryObjectException {
  252.         if(dayFormat==null) {
  253.             throw new SQLQueryObjectException("dayFormat undefined");
  254.         }
  255.         switch (dayFormat) {
  256.         case FULL_DAY_NAME:
  257.         case SHORT_DAY_NAME:
  258.             return super.getExtractDayFormatFromTimestampFieldPrefix(dayFormat);
  259.         case DAY_OF_YEAR:
  260.             return "DAYOFYEAR("; 
  261.         case DAY_OF_WEEK:
  262.             return "DAYOFWEEK("; 
  263.         }
  264.         throw newSQLQueryObjectExceptionDayFormatEnum(dayFormat);
  265.     }
  266.     @Override
  267.     public String getExtractDayFormatFromTimestampFieldSuffix(DayFormatEnum dayFormat) throws SQLQueryObjectException {
  268.         if(dayFormat==null) {
  269.             throw new SQLQueryObjectException("dayFormat undefined");
  270.         }
  271.         switch (dayFormat) {
  272.         case FULL_DAY_NAME:
  273.         case SHORT_DAY_NAME:
  274.             return super.getExtractDayFormatFromTimestampFieldSuffix(dayFormat);
  275.         case DAY_OF_YEAR:
  276.         case DAY_OF_WEEK:
  277.             return ")"; 
  278.         }
  279.         throw newSQLQueryObjectExceptionDayFormatEnum(dayFormat);
  280.     }
  281.     
  282.     
  283.     
  284.     
  285.     
  286.     


  289.     @Override
  290.     public String createSQLQuery() throws SQLQueryObjectException{
  291.         return this.createSQLQuery(false);
  292.     }
  293.     private String createSQLQuery(boolean union) throws SQLQueryObjectException{
  294.         
  295.         this.precheckBuildQuery();
  296.         
  297.         StringBuilder bf = new StringBuilder();

  299.         bf.append("SELECT ");

  301.         if(this.isSelectDistinct())
  302.             bf.append(" DISTINCT ");

  304.         // forzatura di indici
  305.         if( !(this.offset>=0 || this.limit>=0) ){
  306.             Iterator<String> itForceIndex = this.forceIndexTableNames.iterator();
  307.             while(itForceIndex.hasNext()){
  308.                 bf.append(" "+itForceIndex.next()+" ");
  309.             }
  310.         }

  312.         // select field
  313.         addSQLQuerySelectField(bf);

  315.         bf.append(getSQL(false,false,false,union));

  317.         /**if( this.offset>=0 || this.limit>=0)
  318.         //  System.out.println("SQL ["+bf.toString()+"]");*/

  320.         // Limit (senza offset)
  321.         if(this.offset<0 && this.limit>0){
  322.             bf.append(" FETCH FIRST ");
  323.             bf.append(this.limit);
  324.             bf.append(" ROWS ONLY ");
  325.         }

  327.         return bf.toString();
  328.     }
  329.     private void addSQLQuerySelectField(StringBuilder bf) {
  330.         if(this.fields.isEmpty()){
  331.             bf.append("*");
  332.         }else{
  333.             Iterator<String> it = this.fields.iterator();
  334.             boolean first = true;
  335.             while(it.hasNext()){
  336.                 if(!first)
  337.                     bf.append(",");
  338.                 else
  339.                     first = false;

  341.                 String field = it.next();
  342.                 if( this.offset>=0 ){

  344.                     field = this.normalizeField(field,false);

  346.                 } 
  347.                 bf.append(field);
  348.             }
  349.         }
  350.     }





  356.     @Override
  357.     public String createSQLDeleteEngine() throws SQLQueryObjectException {

  359.         StringBuilder bf = new StringBuilder();

  361.         bf.append("DELETE ");

  363.         bf.append(getSQL(true,false,false,false));
  364.         return bf.toString();
  365.     }





  371.     private String getSQL(boolean delete,boolean update,boolean conditions,boolean union) throws SQLQueryObjectException {  
  372.         StringBuilder bf = new StringBuilder();

  374.         if(this.selectForUpdate){
  375.             this.checkSelectForUpdate(update, delete, union);
  376.         }
  377.         
  378.         if(!update && !conditions){
  379.                         
  380.             // From
  381.             bf.append(SQLQueryObjectCore.FROM_SEPARATOR);


  384.             // Se e' presente Offset o Limit
  385.             /**if( (this.offset>=0 || this.limit>=0) && (delete==false)) {*/
  386.             // Rilascio vincolo di order by in caso di limit impostato.
  387.             // Il vincolo rimane per l'offset, per gestire le select annidate di qualche implementazioni come Oracle,SQLServer ...
  388.             if( (this.offset>=0) && (!delete)){

  390.                 /**java.util.List<String> aliasOrderByDistinct = new java.util.ArrayList<>();*/

  392.                 /**if(this.isSelectDistinct()==false)*/         
  393.                 bf.append(SQLQueryObjectCore.SELECT_SEPARATOR_CON_INIZIO_APERTURA);
  394.                 /**else
  395.                 //  bf.append(" ( SELECT DISTINCT ");*/

  397.                 // Questa istruzione ci vuole altrimenti in presenza di order by, group by si ottiene il seguente errore:
  398.                 // The ORDER BY clause is invalid in views, inline functions, derived tables, subqueries, and common table expressions, unless TOP or FOR XML is also specified.
  399.                 // In questo segmento di select forse non server?
  400.                 /** bf.append("TOP 100 PERCENT "); */

  402.                 Iterator<String> itForceIndex = this.forceIndexTableNames.iterator();
  403.                 while(itForceIndex.hasNext()){
  404.                     bf.append(" "+itForceIndex.next()+" ");
  405.                 }

  407.                 if(this.isSelectDistinct()){
  408.                     if(this.fields.isEmpty()){
  409.                         Iterator<String> it = this.tableNames.iterator();
  410.                         boolean first = true;
  411.                         while(it.hasNext()){
  412.                             if(!first)
  413.                                 bf.append(",");
  414.                             else
  415.                                 first = false;
  416.                             String t = it.next();
  417.                             bf.append(t+".*");
  418.                         }
  419.                     }else{
  420.                         Iterator<String> it = this.fields.iterator();
  421.                         boolean first = true;
  422.                         while(it.hasNext()){
  423.                             if(!first)
  424.                                 bf.append(",");
  425.                             else
  426.                                 first = false;

  428.                             String field = it.next();
  429.                             if( this.offset>=0 ){

  431.                                 field = this.normalizeField(field,false);

  433.                             } 
  434.                             bf.append(field);
  435.                         }
  436.                     }
  437.                 }
  438.                 else{
  439.                     if(this.fields.isEmpty()){
  440.                         Iterator<String> it = this.tableNames.iterator();
  441.                         boolean first = true;
  442.                         while(it.hasNext()){
  443.                             if(!first)
  444.                                 bf.append(",");
  445.                             else
  446.                                 first = false;
  447.                             String t = it.next();
  448.                             bf.append(t+".*");
  449.                         }
  450.                     }else{
  451.                         Iterator<String> it = this.fields.iterator();
  452.                         boolean first = true;
  453.                         while(it.hasNext()){
  454.                             if(!first)
  455.                                 bf.append(",");
  456.                             else
  457.                                 first = false;
  458.                             String f = it.next();
  459.                             bf.append(f);
  460.                         }
  461.                     }
  462.                 }


  465.                 bf.append(" , ROW_NUMBER() OVER ( ORDER BY ");

  467.                 // Condizione OrderBy
  468.                 if(this.orderBy.isEmpty()){
  469.                     throw new SQLQueryObjectException(SQLQueryObjectCore.CONDIZIONI_ORDER_BY_RICHESTE);
  470.                 }
  471.                 if(!this.orderBy.isEmpty()){
  472.                     Iterator<String> it = this.orderBy.iterator();
  473.                     boolean first = true;
  474.                     while(it.hasNext()){
  475.                         if(!first)
  476.                             bf.append(",");
  477.                         else
  478.                             first = false;
  479.                         String condizione = it.next();
  480.                         /**System.out.println("=======================");
  481.                         System.out.println("alias: "+this.alias);
  482.                         System.out.println("condizione: "+condizione);
  483.                         System.out.println("KEY: "+(this.alias.containsKey(condizione)));
  484.                         System.out.println("VALUE: "+(this.alias.containsValue(condizione)));
  485.                         System.out.println("DISTINCT: "+(this.isSelectDistinct()));
  486.                         System.out.println("=======================");*/
  487.                         if(this.alias.containsKey(condizione)){
  488.                             if(this.isSelectDistinct()){
  489.                                 bf.append(condizione);
  490.                             }
  491.                             else{
  492.                                 bf.append(this.alias.get(condizione));
  493.                             }
  494.                         }else if(this.alias.containsValue(condizione)) {
  495.                             bf.append(condizione);
  496.                         }
  497.                         else{
  498.                             bf.append(this.normalizeField(condizione));
  499.                         }
  500.                         boolean sortTypeAsc = this.sortTypeAsc;
  501.                         if(this.orderBySortType.containsKey(condizione)){
  502.                             sortTypeAsc = this.orderBySortType.get(condizione);
  503.                         }
  504.                         if(sortTypeAsc){
  505.                             bf.append(SQLQueryObjectCore.ASC_SEPARATOR);
  506.                         }else{
  507.                             bf.append(SQLQueryObjectCore.DESC_SEPARATOR);
  508.                         }
  509.                     }
  510.                 }

  512.                 bf.append(" ) AS rowNumber ");


  515.                 bf.append(SQLQueryObjectCore.FROM_SEPARATOR);

  517.                 if(this.isSelectDistinct()){

  519.                     bf.append(" ( SELECT DISTINCT ");

  521.                     if(this.fields.isEmpty()){
  522.                         Iterator<String> it = this.tableNames.iterator();
  523.                         boolean first = true;
  524.                         while(it.hasNext()){
  525.                             if(!first)
  526.                                 bf.append(",");
  527.                             else
  528.                                 first = false;
  529.                             String t = it.next();
  530.                             bf.append(t+".*");
  531.                         }
  532.                     }else{
  533.                         Iterator<String> it = this.fields.iterator();
  534.                         boolean first = true;
  535.                         while(it.hasNext()){
  536.                             if(!first)
  537.                                 bf.append(",");
  538.                             else
  539.                                 first = false;
  540.                             String f = it.next();
  541.                             bf.append(f);
  542.                         }
  543.                     }

  545.                     bf.append(SQLQueryObjectCore.FROM_SEPARATOR);
  546.                 }


  549.                 // Table dove effettuare la ricerca 'FromTable'
  550.                 if(this.tables.isEmpty()){
  551.                     throw new SQLQueryObjectException(SQLQueryObjectCore.TABELLA_RICERCA_FROM_NON_DEFINITA);
  552.                 }else{
  553.                     Iterator<String> it = this.tables.iterator();
  554.                     boolean first = true;
  555.                     while(it.hasNext()){
  556.                         if(!first)
  557.                             bf.append(",");
  558.                         else
  559.                             first = false;
  560.                         bf.append(it.next());
  561.                     }
  562.                 }

  564.                 // Condizioni di Where
  565.                 if(!this.conditions.isEmpty()){

  567.                     bf.append(SQLQueryObjectCore.WHERE_SEPARATOR);

  569.                     if(this.notBeforeConditions){
  570.                         bf.append(SQLQueryObjectCore.NOT_SEPARATOR_APERTURA);
  571.                     }

  573.                     for(int i=0; i<this.conditions.size(); i++){

  575.                         if(i>0){
  576.                             if(this.andLogicOperator){
  577.                                 bf.append(SQLQueryObjectCore.AND_SEPARATOR);
  578.                             }else{
  579.                                 bf.append(SQLQueryObjectCore.OR_SEPARATOR);
  580.                             }
  581.                         }
  582.                         String cond = this.conditions.get(i);               
  583.                         bf.append(cond);
  584.                     }

  586.                     if(this.notBeforeConditions){
  587.                         bf.append(" )");
  588.                     }
  589.                 }

  591.                 // Condizione GroupBy
  592.                 if((!this.getGroupByConditions().isEmpty()) && (!delete)){
  593.                     bf.append(SQLQueryObjectCore.GROUP_BY_SEPARATOR);
  594.                     Iterator<String> it = this.getGroupByConditions().iterator();
  595.                     boolean first = true;
  596.                     while(it.hasNext()){
  597.                         if(!first)
  598.                             bf.append(",");
  599.                         else
  600.                             first = false;
  601.                         bf.append(it.next());
  602.                     }
  603.                 }


  606.                 if(this.isSelectDistinct()){

  608.                     // Order solo in presenza di select distinct
  609.                     if((!this.orderBy.isEmpty()) && (!delete)){
  610.                         bf.append(SQLQueryObjectCore.ORDER_BY_SEPARATOR);
  611.                         Iterator<String> it = this.orderBy.iterator();
  612.                         boolean first = true;
  613.                         while(it.hasNext()){
  614.                             String column = it.next();
  615.                             if(!first)
  616.                                 bf.append(",");
  617.                             else
  618.                                 first = false;
  619.                             bf.append(column);
  620.                             boolean sortTypeAsc = this.sortTypeAsc;
  621.                             if(this.orderBySortType.containsKey(column)){
  622.                                 sortTypeAsc = this.orderBySortType.get(column);
  623.                             }
  624.                             if(sortTypeAsc){
  625.                                 bf.append(SQLQueryObjectCore.ASC_SEPARATOR);
  626.                             }else{
  627.                                 bf.append(SQLQueryObjectCore.DESC_SEPARATOR);
  628.                             }
  629.                         }
  630.                     }

  632.                     // Devo forzare l'utilizzo di un alias su una sottoselct dentro il FROM         
  633.                     bf.append(" ) ");
  634.                     bf.append(this.getDefaultAliasFieldKeyword());
  635.                     bf.append("tableSelectRaw");
  636.                     // Genero Tre caratteri alfabetici casuali per dare un alias del tipo "tabellaXXX"
  637.                     int rnd; 
  638.                     char base;
  639.                     for (int count=0 ; count < 3; count++ ){
  640.                         rnd = (SQLQueryObjectCore.getRandom().nextInt(52) );
  641.                         base = (rnd < 26) ? 'A' : 'a';
  642.                         bf.append((char) (base + rnd % 26));

  644.                     }
  645.                 }


  648.                 // Devo forzare l'utilizzo di un alias su una sottoselct dentro il FROM         
  649.                 bf.append(" ) ");
  650.                 bf.append(this.getDefaultAliasFieldKeyword());
  651.                 bf.append("tabella");
  652.                 // Genero Tre caratteri alfabetici casuali per dare un alias del tipo "tabellaXXX"
  653.                 int rnd; 
  654.                 char base;
  655.                 for (int count=0 ; count < 3; count++ ){
  656.                     rnd = (SQLQueryObjectCore.getRandom().nextInt(52) );
  657.                     base = (rnd < 26) ? 'A' : 'a';
  658.                     bf.append((char) (base + rnd % 26));

  660.                 }
  661.                 bf.append(" WHERE ( ");

  663.                 if(this.offset>=0){
  664.                     bf.append(" rowNumber > ");
  665.                     bf.append(this.offset);
  666.                 }
  667.                 if(this.limit>=0){
  668.                     if(this.offset>=0)
  669.                         bf.append(" AND");
  670.                     bf.append(" rowNumber <=  ");
  671.                     if(this.offset>=0)
  672.                         bf.append(this.offset+this.limit);
  673.                     else
  674.                         bf.append(this.limit);
  675.                 }
  676.                 bf.append(" )");


  679.                 // ORDER BY FINALE
  680.                 if(!union &&
  681.                     (!this.orderBy.isEmpty())
  682.                     ){
  683.                     bf.append(SQLQueryObjectCore.ORDER_BY_SEPARATOR);
  684.                     Iterator<String> it = this.orderBy.iterator();
  685.                     boolean first = true;
  686.                     while(it.hasNext()){
  687.                         if(!first)
  688.                             bf.append(",");
  689.                         else
  690.                             first = false;
  691.                         String field = it.next();
  692.                         
  693.                         bf.append(this.normalizeField(field));  
  694.                     
  695.                         boolean sortTypeAsc = this.sortTypeAsc;
  696.                         if(this.orderBySortType.containsKey(field)){
  697.                             sortTypeAsc = this.orderBySortType.get(field);
  698.                         }
  699.                         if(sortTypeAsc){
  700.                             bf.append(SQLQueryObjectCore.ASC_SEPARATOR);
  701.                         }else{
  702.                             bf.append(SQLQueryObjectCore.DESC_SEPARATOR);
  703.                         }
  704.                     }
  705.                 }

  707.                 /** 
  708.                  * OLD ALIAS
  709.             if(aliasOrderByDistinct.size()>0){
  710.                 bf.append(SQLQueryObjectCore.ORDER_BY_SEPARATOR);
  711.                 Iterator<String> it = aliasOrderByDistinct.iterator();
  712.                 boolean first = true;
  713.                 while(it.hasNext()){
  714.                     if(!first)
  715.                         bf.append(",");
  716.                     else
  717.                         first = false;
  718.                     bf.append(it.next());
  719.                 }
  720.                 if(this.sortTypeAsc){
  721.                     bf.append(SQLQueryObjectCore.ASC_SEPARATOR);
  722.                 }else{
  723.                     bf.append(SQLQueryObjectCore.DESC_SEPARATOR);
  724.                 }
  725.             }
  726.                  */
  727.                 
  728.             }else{

  730.                 // Offset non presente

  732.                 // Table dove effettuare la ricerca 'FromTable'
  733.                 if(this.tables.isEmpty()){
  734.                     throw new SQLQueryObjectException(SQLQueryObjectCore.TABELLA_RICERCA_FROM_NON_DEFINITA);
  735.                 }else{

  737.                     if(delete && this.tables.size()>2)
  738.                         throw new SQLQueryObjectException("Non e' possibile effettuare una delete con piu' di una tabella alla volta");

  740.                     Iterator<String> it = this.tables.iterator();
  741.                     boolean first = true;
  742.                     while(it.hasNext()){
  743.                         if(!first)
  744.                             bf.append(",");
  745.                         else
  746.                             first = false;
  747.                         bf.append(it.next());
  748.                     }
  749.                 }

  751.                 // Condizioni di Where
  752.                 if(!this.conditions.isEmpty()){
  753.                     bf.append(SQLQueryObjectCore.WHERE_SEPARATOR);

  755.                     if(this.notBeforeConditions){
  756.                         bf.append("NOT (");
  757.                     }

  759.                     for(int i=0; i<this.conditions.size(); i++){
  760.                         if(i>0){
  761.                             if(this.andLogicOperator){
  762.                                 bf.append(SQLQueryObjectCore.AND_SEPARATOR);
  763.                             }else{
  764.                                 bf.append(SQLQueryObjectCore.OR_SEPARATOR);
  765.                             }
  766.                         }
  767.                         bf.append(this.conditions.get(i));
  768.                     }

  770.                     if(this.notBeforeConditions){
  771.                         bf.append(")");
  772.                     }

  774.                 }

  776.                 // Condizione GroupBy
  777.                 if((!this.getGroupByConditions().isEmpty()) && (!delete)){
  778.                     bf.append(SQLQueryObjectCore.GROUP_BY_SEPARATOR);
  779.                     Iterator<String> it = this.getGroupByConditions().iterator();
  780.                     boolean first = true;
  781.                     while(it.hasNext()){
  782.                         if(!first)
  783.                             bf.append(",");
  784.                         else
  785.                             first = false;
  786.                         bf.append(it.next());
  787.                     }
  788.                 }

  790.                 // Condizione OrderBy
  791.                 if(!union &&
  792.                     ((!this.orderBy.isEmpty()) && (!delete))
  793.                     ){
  794.                     bf.append(SQLQueryObjectCore.ORDER_BY_SEPARATOR);
  795.                     Iterator<String> it = this.orderBy.iterator();
  796.                     boolean first = true;
  797.                     while(it.hasNext()){
  798.                         String column = it.next();
  799.                         if(!first)
  800.                             bf.append(",");
  801.                         else
  802.                             first = false;
  803.                         bf.append(column);
  804.                         boolean sortTypeAsc = this.sortTypeAsc;
  805.                         if(this.orderBySortType.containsKey(column)){
  806.                             sortTypeAsc = this.orderBySortType.get(column);
  807.                         }
  808.                         if(sortTypeAsc){
  809.                             bf.append(SQLQueryObjectCore.ASC_SEPARATOR);
  810.                         }else{
  811.                             bf.append(SQLQueryObjectCore.DESC_SEPARATOR);
  812.                         }
  813.                     }
  814.                 }
  815.                 
  816.                 // ForUpdate
  817.                 if(this.selectForUpdate){
  818.                     bf.append(" FOR UPDATE ");
  819.                 }
  820.             }
  821.         }else{

  823.             // UPDATE, conditions

  825.             // Condizioni di Where
  826.             if(!this.conditions.isEmpty()){

  828.                 if(!conditions)
  829.                     bf.append(SQLQueryObjectCore.WHERE_SEPARATOR);

  831.                 if(this.notBeforeConditions){
  832.                     bf.append("NOT (");
  833.                 }

  835.                 for(int i=0; i<this.conditions.size(); i++){
  836.                     if(i>0){
  837.                         if(this.andLogicOperator){
  838.                             bf.append(SQLQueryObjectCore.AND_SEPARATOR);
  839.                         }else{
  840.                             bf.append(SQLQueryObjectCore.OR_SEPARATOR);
  841.                         }
  842.                     }
  843.                     bf.append(this.conditions.get(i));
  844.                 }

  846.                 if(this.notBeforeConditions){
  847.                     bf.append(")");
  848.                 }

  850.             }
  851.             
  852.             // Non genero per le condizioni, per update viene sollevata eccezione prima
  853.             // ForUpdate
  854. /**         if(this.selectForUpdate){
  855. //              bf.append(" FOR UPDATE ");
  856. //          }*/
  857.         }

  859.         return bf.toString();
  860.     }
  861.     
  862.     
  863.     @Override
  864.     public String createSQLUnion(boolean unionAll,
  865.             ISQLQueryObject... sqlQueryObject) throws SQLQueryObjectException {

  867.         // Controllo parametro su cui effettuare la UNION
  868.         this.checkUnionField(false,sqlQueryObject);

  870.         if(this.selectForUpdate){
  871.             this.checkSelectForUpdate(false, false, true);
  872.         }
  873.         
  874.         StringBuilder bf = new StringBuilder();

  876.         // Non ha senso, la union fa gia la distinct, a meno di usare la unionAll ma in quel caso non si vuole la distinct
  877.         /** if(this.isSelectDistinct())
  878.         //  bf.append(" DISTINCT ");*/

  880.         // Se e' presente Offset o Limit
  881.         // Rilascio vincolo di order by in caso di limit impostato.
  882.         // Il vincolo rimane per l'offset, per gestire le select annidate di qualche implementazioni come Oracle,SQLServer ...
  883.         /**if( (this.offset>=0 || this.limit>=0) ){*/
  884.         if( this.offset>=0 ){

  886.             bf.append("SELECT * from ");

  888.             bf.append(SQLQueryObjectCore.SELECT_SEPARATOR_CON_INIZIO_APERTURA);

  890.             if(this.fields.isEmpty()){
  891.                 Iterator<String> it = this.tableNames.iterator();
  892.                 boolean first = true;
  893.                 while(it.hasNext()){
  894.                     if(!first)
  895.                         bf.append(",");
  896.                     else
  897.                         first = false;
  898.                     String t = it.next();
  899.                     bf.append(t+".*");
  900.                 }
  901.             }else{
  902.                 Iterator<String> it = this.fields.iterator();
  903.                 boolean first = true;
  904.                 while(it.hasNext()){
  905.                     if(!first)
  906.                         bf.append(",");
  907.                     else
  908.                         first = false;
  909.                     String f = it.next();
  910.                     bf.append(f);
  911.                 }
  912.             }

  914.             bf.append(" , ROW_NUMBER() OVER ( ORDER BY ");

  916.             // Condizione OrderBy
  917.             if(this.orderBy.isEmpty()){
  918.                 throw new SQLQueryObjectException(SQLQueryObjectCore.CONDIZIONI_ORDER_BY_RICHESTE);
  919.             }
  920.             if(!this.orderBy.isEmpty()){
  921.                 Iterator<String> it = this.orderBy.iterator();
  922.                 boolean first = true;
  923.                 while(it.hasNext()){
  924.                     if(!first)
  925.                         bf.append(",");
  926.                     else
  927.                         first = false;
  928.                     String condizione = it.next();
  929.                     if(this.alias.containsKey(condizione)){
  930.                         bf.append(this.alias.get(condizione));
  931.                     }else{
  932.                         bf.append(condizione);
  933.                     }
  934.                     boolean sortTypeAsc = this.sortTypeAsc;
  935.                     if(this.orderBySortType.containsKey(condizione)){
  936.                         sortTypeAsc = this.orderBySortType.get(condizione);
  937.                     }
  938.                     if(sortTypeAsc){
  939.                         bf.append(SQLQueryObjectCore.ASC_SEPARATOR);
  940.                     }else{
  941.                         bf.append(SQLQueryObjectCore.DESC_SEPARATOR);
  942.                     }
  943.                 }
  944.             }

  946.             bf.append(" ) AS rowNumber ");

  948.             // Table dove effettuare la ricerca 'FromTable'
  949.             bf.append(SQLQueryObjectCore.FROM_SEPARATOR_APERTURA);

  951.             for(int i=0; i<sqlQueryObject.length; i++){

  953.                 if(((DB2QueryObject)sqlQueryObject[i]).selectForUpdate){
  954.                     try{
  955.                         ((DB2QueryObject)sqlQueryObject[i]).checkSelectForUpdate(false, false, true);
  956.                     }catch(Exception e){
  957.                         throw new SQLQueryObjectException("Parametro SqlQueryObject["+i+"] non valido: "+e.getMessage());
  958.                     }
  959.                 }
  960.                 
  961.                 if(i>0){
  962.                     bf.append(" UNION ");
  963.                     if(unionAll){
  964.                         bf.append(" ALL ");
  965.                     }
  966.                 }

  968.                 bf.append("( ");

  970.                 bf.append(((DB2QueryObject)sqlQueryObject[i]).createSQLQuery(true));

  972.                 bf.append(") ");
  973.             }

  975.             bf.append(SQLQueryObjectCore.AS_SUBQUERY_SUFFIX+getSerial()+" ");

  977.             // Condizioni di Where
  978.             if(!this.conditions.isEmpty()){

  980.                 bf.append(SQLQueryObjectCore.WHERE_SEPARATOR);

  982.                 if(this.notBeforeConditions){
  983.                     bf.append(SQLQueryObjectCore.NOT_SEPARATOR_APERTURA);
  984.                 }

  986.                 for(int i=0; i<this.conditions.size(); i++){

  988.                     if(i>0){
  989.                         if(this.andLogicOperator){
  990.                             bf.append(SQLQueryObjectCore.AND_SEPARATOR);
  991.                         }else{
  992.                             bf.append(SQLQueryObjectCore.OR_SEPARATOR);
  993.                         }
  994.                     }
  995.                     String cond = this.conditions.get(i);
  996.                     bf.append(cond);
  997.                 }

  999.                 if(this.notBeforeConditions){
  1000.                     bf.append(" )");
  1001.                 }
  1002.             }

  1004.             // Condizione GroupBy
  1005.             if((!this.getGroupByConditions().isEmpty())){
  1006.                 bf.append(SQLQueryObjectCore.GROUP_BY_SEPARATOR);
  1007.                 Iterator<String> it = this.getGroupByConditions().iterator();
  1008.                 boolean first = true;
  1009.                 while(it.hasNext()){
  1010.                     if(!first)
  1011.                         bf.append(",");
  1012.                     else
  1013.                         first = false;
  1014.                     bf.append(it.next());
  1015.                 }
  1016.             }

  1018.             bf.append(SQLQueryObjectCore.AS_SUBQUERY_SUFFIX+getSerial()+" ");

  1020.             bf.append(" WHERE ( ");
  1021.             if(this.offset>=0){
  1022.                 bf.append(" rowNumber > ");
  1023.                 bf.append(this.offset);
  1024.             }
  1025.             if(this.limit>=0){
  1026.                 if(this.offset>=0)
  1027.                     bf.append(" AND");
  1028.                 bf.append(" rowNumber <=  ");
  1029.                 if(this.offset>=0)
  1030.                     bf.append(this.offset+this.limit);
  1031.                 else
  1032.                     bf.append(this.limit);
  1033.             }
  1034.             bf.append(" )");


  1037.         }else{

  1039.             // no offset

  1041.             bf.append("SELECT ");


  1044.             Iterator<String> itForceIndex = this.forceIndexTableNames.iterator();
  1045.             while(itForceIndex.hasNext()){
  1046.                 bf.append(" "+itForceIndex.next()+" ");
  1047.             }

  1049.             if(this.fields.isEmpty()){
  1050.                 bf.append("*");
  1051.             }else{
  1052.                 Iterator<String> it = this.fields.iterator();
  1053.                 boolean first = true;
  1054.                 while(it.hasNext()){
  1055.                     if(!first)
  1056.                         bf.append(",");
  1057.                     else
  1058.                         first = false;
  1059.                     String f = it.next();
  1060.                     bf.append(f);
  1061.                 }
  1062.             }

  1064.             bf.append(SQLQueryObjectCore.FROM_SEPARATOR_APERTURA);

  1066.             for(int i=0; i<sqlQueryObject.length; i++){

  1068.                 if(((DB2QueryObject)sqlQueryObject[i]).selectForUpdate){
  1069.                     try{
  1070.                         ((DB2QueryObject)sqlQueryObject[i]).checkSelectForUpdate(false, false, true);
  1071.                     }catch(Exception e){
  1072.                         throw new SQLQueryObjectException("Parametro SqlQueryObject["+i+"] non valido: "+e.getMessage());
  1073.                     }
  1074.                 }
  1075.                 
  1076.                 if(i>0){
  1077.                     bf.append(" UNION ");
  1078.                     if(unionAll){
  1079.                         bf.append(" ALL ");
  1080.                     }
  1081.                 }

  1083.                 bf.append("( ");

  1085.                 bf.append(((DB2QueryObject)sqlQueryObject[i]).createSQLQuery(true));

  1087.                 bf.append(") ");
  1088.             }

  1090.             bf.append(SQLQueryObjectCore.AS_SUBQUERY_SUFFIX+getSerial()+" ");


  1093.             // Condizione GroupBy
  1094.             if((!this.getGroupByConditions().isEmpty())){
  1095.                 bf.append(SQLQueryObjectCore.GROUP_BY_SEPARATOR);
  1096.                 Iterator<String> it = this.getGroupByConditions().iterator();
  1097.                 boolean first = true;
  1098.                 while(it.hasNext()){
  1099.                     if(!first)
  1100.                         bf.append(",");
  1101.                     else
  1102.                         first = false;
  1103.                     bf.append(it.next());
  1104.                 }
  1105.             }

  1107.             // Condizione OrderBy
  1108.             if(!this.orderBy.isEmpty()){
  1109.                 bf.append(SQLQueryObjectCore.ORDER_BY_SEPARATOR);
  1110.                 Iterator<String> it = this.orderBy.iterator();
  1111.                 boolean first = true;
  1112.                 while(it.hasNext()){
  1113.                     String column = it.next();
  1114.                     if(!first)
  1115.                         bf.append(",");
  1116.                     else
  1117.                         first = false;
  1118.                     bf.append(column);
  1119.                     boolean sortTypeAsc = this.sortTypeAsc;
  1120.                     if(this.orderBySortType.containsKey(column)){
  1121.                         sortTypeAsc = this.orderBySortType.get(column);
  1122.                     }
  1123.                     if(sortTypeAsc){
  1124.                         bf.append(SQLQueryObjectCore.ASC_SEPARATOR);
  1125.                     }else{
  1126.                         bf.append(SQLQueryObjectCore.DESC_SEPARATOR);
  1127.                     }
  1128.                 }
  1129.             }

  1131.             // Limit (senza offset)
  1132.             if(this.offset<0 && this.limit>0){
  1133.                 bf.append(" FETCH FIRST ");
  1134.                 bf.append(this.limit);
  1135.                 bf.append(" ROWS ONLY ");
  1136.             }
  1137.         }

  1139.         return bf.toString();
  1140.     }

  1142.     @Override
  1143.     public String createSQLUnionCount(boolean unionAll, String aliasCount,
  1144.             ISQLQueryObject... sqlQueryObject) throws SQLQueryObjectException {

  1146.         // Controllo parametro su cui effettuare la UNION
  1147.         this.checkUnionField(true,sqlQueryObject);

  1149.         if(aliasCount==null){
  1150.             throw new SQLQueryObjectException("Alias per il count non definito");
  1151.         }

  1153.         StringBuilder bf = new StringBuilder();

  1155.         bf.append("SELECT count(*) "+this.getDefaultAliasFieldKeyword()+" ");
  1156.         bf.append(aliasCount);
  1157.         bf.append(SQLQueryObjectCore.FROM_SEPARATOR_APERTURA);

  1159.         bf.append( this.createSQLUnion(unionAll, sqlQueryObject) );

  1161.         bf.append(SQLQueryObjectCore.AS_SUBQUERY_SUFFIX+getSerial()+" ");

  1163.         return bf.toString();
  1164.     }

  1166.     @Override
  1167.     public String createSQLUpdateEngine() throws SQLQueryObjectException {
  1168.         
  1169.         StringBuilder bf = new StringBuilder();
  1170.         bf.append("UPDATE ");
  1171.         bf.append(this.updateTable);
  1172.         bf.append(" SET ");
  1173.         for(int i=0; i<this.updateFieldsName.size(); i++){
  1174.             if(i>0)
  1175.                 bf.append(" , ");
  1176.             bf.append(this.updateFieldsName.get(i));
  1177.             bf.append(" = ");
  1178.             bf.append(this.updateFieldsValue.get(i));
  1179.         }
  1180.         bf.append(getSQL(false,true,false,false));
  1181.         return bf.toString();
  1182.     }








  1191.     /* ---------------- WHERE CONDITIONS ------------------ */

  1193.     @Override
  1194.     public String createSQLConditionsEngine() throws SQLQueryObjectException {
  1195.         
  1196.         StringBuilder bf = new StringBuilder();
  1197.         bf.append(getSQL(false,false,true,false));
  1198.         return bf.toString();
  1199.     }



  1203. }
Created with JaCoCo 0.8.8.202204050719