DerbyQueryObject.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.  * Implementazione per HyperSQL
  32.  *
  33.  * @author Poli Andrea (apoli@link.it)
  34.  * @author $Author$
  35.  * @version $Rev$, $Date$
  36.  */
  37. public class DerbyQueryObject extends SQLQueryObjectCore {

  39.     public DerbyQueryObject(TipiDatabase tipoDatabase) {
  40.         super(tipoDatabase);
  41.     }

  43.     
  44.     /**
  45.      * Ritorna una costante  di tipo 'timestamp'
  46.      * 
  47.      * @param date Costante
  48.      */
  49.     @Override
  50.     public String getSelectTimestampConstantField(Date date) throws SQLQueryObjectException{
  51.         SimpleDateFormat sqlDateformat = DateUtils.getDefaultDateTimeFormatter("yyyy-MM-dd HH:mm:ss.SSS");
  52.         return "CAST('"+sqlDateformat.format(date)+"' AS TIMESTAMP)";
  53.     }
  54.     
  55.     
  56.     
  57.     @Override
  58.     public String getUnixTimestampConversion(String column){
  59.         /**return "((datediff('ss',CAST('1970-01-01 00:00:00' AS TIMESTAMP),"+column+")-3600)*1000)";*/
  60.         return "( "+ 
  61.                 "("+
  62.                 "(UNIX_TIMESTAMP("+column+")*1000) - "+
  63.                 "((EXTRACT(HOUR FROM TIMEZONE()))*60*60*1000)" +
  64.                 ") + "+
  65.                 "(CAST(CHAR ("+column+") AS INTEGER))" +
  66.                 ")"
  67.                 ;
  68.     }
  69.     
  70.     @Override
  71.     public String getDiffUnixTimestamp(String columnMax,String columnMin){
  72.         return "( "+getUnixTimestampConversion(columnMax)+" - "+getUnixTimestampConversion(columnMin)+" )";
  73.     }
  74.     
  75.     
  76.     
  77.     @Override
  78.     public ISQLQueryObject addSelectAvgTimestampField(String field, String alias)
  79.             throws SQLQueryObjectException {
  80.         if(field==null)
  81.             throw new SQLQueryObjectException(SQLQueryObjectCore.FIELD_DEVE_ESSERE_DIVERSO_NULL);
  82.         // Trasformo in UNIX_TIMESTAMP
  83.         String fieldSQL = "avg("+this.getUnixTimestampConversion(field)+")";
  84.         if(alias != null){
  85.             /** fieldSQL = fieldSQL + " as "+alias;*/
  86.             fieldSQL = fieldSQL +this.getDefaultAliasFieldKeyword()+alias;
  87.         }
  88.         this.engineAddSelectField(null,fieldSQL,null,false,true);
  89.         this.fieldNames.add(alias);
  90.         return this;
  91.     }

  93.     @Override
  94.     public ISQLQueryObject addSelectMaxTimestampField(String field, String alias)
  95.             throws SQLQueryObjectException {
  96.         if(field==null)
  97.             throw new SQLQueryObjectException(SQLQueryObjectCore.FIELD_DEVE_ESSERE_DIVERSO_NULL);
  98.         // Trasformo in UNIX_TIMESTAMP
  99.         String fieldSQL = "max("+this.getUnixTimestampConversion(field)+")";
  100.         if(alias != null){
  101.             /**fieldSQL = fieldSQL + " as "+alias;*/
  102.             fieldSQL = fieldSQL +this.getDefaultAliasFieldKeyword()+alias;
  103.         }
  104.         this.engineAddSelectField(null,fieldSQL,null,false,true);
  105.         this.fieldNames.add(alias);
  106.         return this;
  107.     }

  109.     @Override
  110.     public ISQLQueryObject addSelectMinTimestampField(String field, String alias)
  111.             throws SQLQueryObjectException {
  112.         if(field==null)
  113.             throw new SQLQueryObjectException(SQLQueryObjectCore.FIELD_DEVE_ESSERE_DIVERSO_NULL);
  114.         // Trasformo in UNIX_TIMESTAMP
  115.         String fieldSQL = "min("+this.getUnixTimestampConversion(field)+")";
  116.         if(alias != null){
  117.             /**fieldSQL = fieldSQL + " as "+alias;*/
  118.             fieldSQL = fieldSQL +this.getDefaultAliasFieldKeyword()+alias;
  119.         }
  120.         this.engineAddSelectField(null,fieldSQL,null,false,true);
  121.         this.fieldNames.add(alias);
  122.         return this;
  123.     }

  125.     @Override
  126.     public ISQLQueryObject addSelectSumTimestampField(String field, String alias)
  127.             throws SQLQueryObjectException {
  128.         if(field==null)
  129.             throw new SQLQueryObjectException(SQLQueryObjectCore.FIELD_DEVE_ESSERE_DIVERSO_NULL);
  130.         // Trasformo in UNIX_TIMESTAMP
  131.         String fieldSQL = "sum("+this.getUnixTimestampConversion(field)+")";
  132.         if(alias != null){
  133.             /**fieldSQL = fieldSQL + " as "+alias;*/
  134.             fieldSQL = fieldSQL +this.getDefaultAliasFieldKeyword()+alias;
  135.         }
  136.         this.engineAddSelectField(null,fieldSQL,null,false,true);
  137.         this.fieldNames.add(alias);
  138.         return this;
  139.     }
  140.     
  141.     
  142.     
  143.     
  144.     
  145.     
  146.     @Override
  147.     public ISQLQueryObject addFromTable(ISQLQueryObject subSelect)
  148.             throws SQLQueryObjectException {
  149.         StringBuilder bf = new StringBuilder();
  150.         bf.append(" ( ");
  151.         bf.append(subSelect.createSQLQuery());
  152.         bf.append(" ) ");
  153.         this.addFromTable(bf.toString());
  154.         return this;
  155.     }
  156.     
  157.     
  158.     
  159.     
  160.     @Override
  161.     protected EscapeSQLConfiguration getEscapeSQLConfiguration(){
  162.         
  163.         EscapeSQLConfiguration config = new EscapeSQLConfiguration();
  164.         config.addCharacter('_');
  165.         config.addCharacter('%');
  166.         config.addCharacter('\\');
  167.         config.setUseEscapeClausole(true);
  168.         config.setEscape('\\');
  169.         
  170.         // special
  171.         config.addCharacterWithOtherEscapeChar('\'','\'');
  172.         
  173.         return config;
  174.     }
  175.     
  176.     
  177.     
  178.     
  179.     
  180.     
  181.     
  182.     
  183.     
  184.     
  185.     private SQLQueryObjectException newSQLQueryObjectExceptionDayFormatEnum(DayFormatEnum dayFormat) {
  186.         return new SQLQueryObjectException("DayFormatEnum '"+dayFormat+"' unknown");
  187.     }
  188.     @Override
  189.     public String getExtractDayFormatFromTimestampFieldPrefix(DayFormatEnum dayFormat) throws SQLQueryObjectException {
  190.         if(dayFormat==null) {
  191.             throw new SQLQueryObjectException("dayFormat undefined");
  192.         }
  193.         switch (dayFormat) {
  194.         case FULL_DAY_NAME:
  195.             return "DAYNAME(";
  196.         case SHORT_DAY_NAME:
  197.             return "DATE_FORMAT(";
  198.         case DAY_OF_YEAR:
  199.             return "DAYOFYEAR("; 
  200.         case DAY_OF_WEEK:
  201.             return "DAYOFWEEK("; 
  202.         }
  203.         throw newSQLQueryObjectExceptionDayFormatEnum(dayFormat);
  204.     }
  205.     @Override
  206.     public String getExtractDayFormatFromTimestampFieldSuffix(DayFormatEnum dayFormat) throws SQLQueryObjectException {
  207.         if(dayFormat==null) {
  208.             throw new SQLQueryObjectException("dayFormat undefined");
  209.         }
  210.         switch (dayFormat) {
  211.         case SHORT_DAY_NAME:
  212.             return ", '%a')"; 
  213.         case FULL_DAY_NAME:
  214.         case DAY_OF_YEAR:
  215.         case DAY_OF_WEEK:
  216.             return ")"; 
  217.         }
  218.         throw newSQLQueryObjectExceptionDayFormatEnum(dayFormat);
  219.     }
  220.     
  221.     
  222.     
  223.     
  224.     
  225.     
  226.     
  227.     @Override
  228.     public String createSQLQuery() throws SQLQueryObjectException{
  229.         return this.createSQLQuery(false);
  230.     }
  231.     private String createSQLQuery(boolean union) throws SQLQueryObjectException{
  232.         
  233.         this.precheckBuildQuery();
  234.         
  235.         StringBuilder bf = new StringBuilder();
  236.         
  237.         bf.append("SELECT ");
  238.         
  239.         // forzatura di indici
  240.         Iterator<String> itForceIndex = this.forceIndexTableNames.iterator();
  241.         while(itForceIndex.hasNext()){
  242.             bf.append(" "+itForceIndex.next()+" ");
  243.         }
  244.         
  245.         if(this.isSelectDistinct())
  246.             bf.append(" DISTINCT ");
  247.         
  248.         // select field
  249.         if(this.fields.isEmpty()){
  250.             bf.append("*");
  251.         }else{
  252.             Iterator<String> it = this.fields.iterator();
  253.             boolean first = true;
  254.             while(it.hasNext()){
  255.                 if(!first)
  256.                     bf.append(",");
  257.                 else
  258.                     first = false;
  259.                 bf.append(it.next());
  260.             }
  261.         }
  262.         
  263.         bf.append(getSQL(false,false,false,union));
  264.         
  265.         /**if( this.offset>=0 || this.limit>=0)
  266.         //  System.out.println("SQL ["+bf.toString()+"]");*/
  267.         
  268.         return bf.toString();
  269.     }

  271.     
  272.     
  273.     
  274.     @Override
  275.     public String createSQLDeleteEngine() throws SQLQueryObjectException {
  276.         StringBuilder bf = new StringBuilder();
  277.                 
  278.         bf.append("DELETE ");
  279.         
  280.         bf.append(getSQL(true,false,false,false));
  281.         return bf.toString();
  282.     }
  283.     
  284.     
  285.     
  286.     

  288.     
  289.     /**
  290.      * @return SQL
  291.      * @throws SQLQueryObjectException
  292.      */
  293.     private String getSQL(boolean delete,boolean update,boolean conditions,boolean union) throws SQLQueryObjectException {
  294.         StringBuilder bf = new StringBuilder();

  296.         if(this.selectForUpdate){
  297.             this.checkSelectForUpdate(update, delete, union);
  298.         }
  299.         
  300.         if(!update && !conditions){
  301.             // From
  302.             bf.append(SQLQueryObjectCore.FROM_SEPARATOR);
  303.             
  304.             // Table dove effettuare la ricerca 'FromTable'
  305.             if(this.tables.isEmpty()){
  306.                 throw new SQLQueryObjectException(SQLQueryObjectCore.TABELLA_RICERCA_FROM_NON_DEFINITA);
  307.             }else{
  308.                 if(delete && this.tables.size()>2)
  309.                     throw new SQLQueryObjectException("Non e' possibile effettuare una delete con piu' di una tabella alla volta");
  310.                 Iterator<String> it = this.tables.iterator();
  311.                 boolean first = true;
  312.                 while(it.hasNext()){
  313.                     if(!first)
  314.                         bf.append(",");
  315.                     else
  316.                         first = false;
  317.                     bf.append(it.next());
  318.                 }
  319.             }
  320.         }
  321.         
  322.         // Condizioni di Where
  323.         if(!this.conditions.isEmpty()){
  324.             
  325.             if(!conditions)
  326.                 bf.append(SQLQueryObjectCore.WHERE_SEPARATOR);
  327.             
  328.             if(this.notBeforeConditions){
  329.                 bf.append("NOT (");
  330.             }
  331.             
  332.             for(int i=0; i<this.conditions.size(); i++){
  333.                 if(i>0){
  334.                     if(this.andLogicOperator){
  335.                         bf.append(SQLQueryObjectCore.AND_SEPARATOR);
  336.                     }else{
  337.                         bf.append(SQLQueryObjectCore.OR_SEPARATOR);
  338.                     }
  339.                 }
  340.                 bf.append(this.conditions.get(i));
  341.             }
  342.             
  343.             if(this.notBeforeConditions){
  344.                 bf.append(")");
  345.             }
  346.         }
  347.         
  348.         // Condizione GroupBy
  349.         if((!this.getGroupByConditions().isEmpty()) && (!delete) && (!update) && (!conditions)){
  350.             bf.append(SQLQueryObjectCore.GROUP_BY_SEPARATOR);
  351.             Iterator<String> it = this.getGroupByConditions().iterator();
  352.             boolean first = true;
  353.             while(it.hasNext()){
  354.                 if(!first)
  355.                     bf.append(",");
  356.                 else
  357.                     first = false;
  358.                 bf.append(it.next());
  359.             }
  360.         }
  361.         
  362.         // Condizione OrderBy
  363. /**     if(union==false){ La condizione di OrderBy DEVE essere generata. In SQLServer e MySQL viene generata durante la condizione di LIMIT/OFFSET*/
  364.         // NOTA: L'order by insieme al LIMIT e OFFSET, all'interno di sotto-select come in questo caso della union, funziona solo con HSQL 2.x
  365.             if((!this.orderBy.isEmpty()) && (!delete) && (!update) && (!conditions) ){
  366.                 bf.append(SQLQueryObjectCore.ORDER_BY_SEPARATOR);
  367.                 Iterator<String> it = this.orderBy.iterator();
  368.                 boolean first = true;
  369.                 while(it.hasNext()){
  370.                     String column = it.next();
  371.                     if(!first)
  372.                         bf.append(",");
  373.                     else
  374.                         first = false;
  375.                     bf.append(column);
  376.                     boolean sortTypeAsc = this.sortTypeAsc;
  377.                     if(this.orderBySortType.containsKey(column)){
  378.                         sortTypeAsc = this.orderBySortType.get(column);
  379.                     }
  380.                     if(sortTypeAsc){
  381.                         bf.append(SQLQueryObjectCore.ASC_SEPARATOR);
  382.                     }else{
  383.                         bf.append(SQLQueryObjectCore.DESC_SEPARATOR);
  384.                     }
  385.                 }
  386.             }
  387. /**     }*/

  389.             
  390.         // Limit e Offset
  391.         /**if(this.limit>0 || this.offset>0){*/
  392.         // Rilascio vincolo di order by in caso di limit impostato.
  393.         // Il vincolo rimane per l'offset, per gestire le select annidate di qualche implementazioni come Oracle,SQLServer ...
  394.         if(this.offset>=0 &&
  395.             (this.orderBy.isEmpty())
  396.             ){
  397.             throw new SQLQueryObjectException(SQLQueryObjectCore.CONDIZIONI_ORDER_BY_RICHESTE);
  398.         }
  399.         
  400.         
  401.         // Offset
  402.         if((this.offset>=0) && (!delete) && (!update) && (!conditions)){
  403.             bf.append(" OFFSET ");
  404.             bf.append(this.offset);
  405.             bf.append(" ROWS ");
  406.         }
  407.         
  408.         // Limit (con offset)
  409.         if((this.limit>0) && (!delete) && (!update) && (!conditions)){
  410.             bf.append(" FETCH NEXT ");
  411.             bf.append(this.limit);
  412.             bf.append(" ROWS ONLY ");
  413.         }
  414.         
  415.         // ForUpdate
  416.         if(!conditions &&
  417.             (this.selectForUpdate)
  418.             ){
  419.             bf.append(" FOR UPDATE ");
  420.         }
  421.         
  422.         return bf.toString();
  423.     }
  424.     
  425.     
  426.     
  427.     @Override
  428.     public String createSQLUnion(boolean unionAll,
  429.             ISQLQueryObject... sqlQueryObject) throws SQLQueryObjectException {
  430.         
  431.         // Controllo parametro su cui effettuare la UNION
  432.         this.checkUnionField(false,sqlQueryObject);
  433.         
  434.         if(this.selectForUpdate){
  435.             this.checkSelectForUpdate(false, false, true);
  436.         }
  437.         
  438.         StringBuilder bf = new StringBuilder();
  439.         
  440.         bf.append("SELECT ");
  441.         
  442.         // Non ha senso, la union fa gia la distinct, a meno di usare la unionAll ma in quel caso non si vuole la distinct
  443.         /** if(this.isSelectDistinct())
  444.         //  bf.append(" DISTINCT ");*/
  445.         
  446.         // forzatura di indici
  447.         Iterator<String> itForceIndex = this.forceIndexTableNames.iterator();
  448.         while(itForceIndex.hasNext()){
  449.             bf.append(" "+itForceIndex.next()+" ");
  450.         }
  451.                 
  452.         // select field
  453.         if(this.fields.isEmpty()){
  454.             bf.append("*");
  455.         }else{
  456.             Iterator<String> it = this.fields.iterator();
  457.             boolean first = true;
  458.             while(it.hasNext()){
  459.                 if(!first)
  460.                     bf.append(",");
  461.                 else
  462.                     first = false;
  463.                 bf.append(it.next());
  464.             }
  465.         }
  466.         
  467.         bf.append(SQLQueryObjectCore.FROM_SEPARATOR_APERTURA);
  468.         
  469.         for(int i=0; i<sqlQueryObject.length; i++){
  470.             
  471.             if(((DerbyQueryObject)sqlQueryObject[i]).selectForUpdate){
  472.                 try{
  473.                     ((DerbyQueryObject)sqlQueryObject[i]).checkSelectForUpdate(false, false, true);
  474.                 }catch(Exception e){
  475.                     throw new SQLQueryObjectException("Parametro SqlQueryObject["+i+"] non valido: "+e.getMessage());
  476.                 }
  477.             }
  478.             
  479.             if(i>0){
  480.                 bf.append(" UNION ");
  481.                 if(unionAll){
  482.                     bf.append(" ALL ");
  483.                 }
  484.             }
  485.             
  486.             bf.append("( ");
  487.             
  488.             bf.append(((DerbyQueryObject)sqlQueryObject[i]).createSQLQuery(true));
  489.             
  490.             bf.append(") ");
  491.         }
  492.         
  493.         bf.append(SQLQueryObjectCore.AS_SUBQUERY_SUFFIX+getSerial()+" ");
  494.         
  495.         // Condizione GroupBy
  496.         if((!this.getGroupByConditions().isEmpty()) ){
  497.             bf.append(SQLQueryObjectCore.GROUP_BY_SEPARATOR);
  498.             Iterator<String> it = this.getGroupByConditions().iterator();
  499.             boolean first = true;
  500.             while(it.hasNext()){
  501.                 if(!first)
  502.                     bf.append(",");
  503.                 else
  504.                     first = false;
  505.                 bf.append(it.next());
  506.             }
  507.         }
  508.         
  509.         // Condizione OrderBy
  510.         if(!this.orderBy.isEmpty()){
  511.             bf.append(SQLQueryObjectCore.ORDER_BY_SEPARATOR);
  512.             Iterator<String> it = this.orderBy.iterator();
  513.             boolean first = true;
  514.             while(it.hasNext()){
  515.                 String column = it.next();
  516.                 if(!first)
  517.                     bf.append(",");
  518.                 else
  519.                     first = false;
  520.                 bf.append(column);
  521.                 boolean sortTypeAsc = this.sortTypeAsc;
  522.                 if(this.orderBySortType.containsKey(column)){
  523.                     sortTypeAsc = this.orderBySortType.get(column);
  524.                 }
  525.                 if(sortTypeAsc){
  526.                     bf.append(SQLQueryObjectCore.ASC_SEPARATOR);
  527.                 }else{
  528.                     bf.append(SQLQueryObjectCore.DESC_SEPARATOR);
  529.                 }
  530.             }
  531.         }
  532.         
  533.         // Limit e Offset
  534.         /**if(this.limit>0 || this.offset>0){*/
  535.         // Rilascio vincolo di order by in caso di limit impostato.
  536.         // Il vincolo rimane per l'offset, per gestire le select annidate di qualche implementazioni come Oracle,SQLServer ...
  537.         if(this.offset>=0 &&
  538.             (this.orderBy.isEmpty())
  539.             ){
  540.             throw new SQLQueryObjectException(SQLQueryObjectCore.CONDIZIONI_ORDER_BY_RICHESTE);
  541.         }
  542.         
  543.         // Offset
  544.         if(this.offset>=0){
  545.             bf.append(" OFFSET ");
  546.             bf.append(this.offset);
  547.             bf.append(" ROWS ");
  548.         }
  549.         
  550.         // Limit 
  551.         if(this.limit>0){
  552.             bf.append(" FETCH NEXT ");
  553.             bf.append(this.limit);
  554.             bf.append(" ROWS ONLY ");
  555.         }
  556.         
  557.         return bf.toString();
  558.         
  559.     }

  561.     @Override
  562.     public String createSQLUnionCount(boolean unionAll, String aliasCount,
  563.             ISQLQueryObject... sqlQueryObject) throws SQLQueryObjectException {
  564.         // Controllo parametro su cui effettuare la UNION
  565.         this.checkUnionField(true,sqlQueryObject);
  566.         
  567.         if(aliasCount==null){
  568.             throw new SQLQueryObjectException("Alias per il count non definito");
  569.         }
  570.         
  571.         StringBuilder bf = new StringBuilder();
  572.         
  573.         bf.append("SELECT count(*) "+this.getDefaultAliasFieldKeyword()+" ");
  574.         bf.append(aliasCount);
  575.         bf.append(SQLQueryObjectCore.FROM_SEPARATOR_APERTURA);
  576.         
  577.         bf.append( this.createSQLUnion(unionAll, sqlQueryObject) );
  578.         
  579.         bf.append(SQLQueryObjectCore.AS_SUBQUERY_SUFFIX+getSerial()+" ");
  580.             
  581.         return bf.toString();
  582.     }
  583.     
  584.     
  585.     

  587.     @Override
  588.     public String createSQLUpdateEngine() throws SQLQueryObjectException {

  590.         StringBuilder bf = new StringBuilder();
  591.         bf.append("UPDATE ");
  592.         bf.append(this.updateTable);
  593.         bf.append(" SET ");
  594.         for(int i=0; i<this.updateFieldsName.size(); i++){
  595.             if(i>0)
  596.                 bf.append(" , ");
  597.             bf.append(this.updateFieldsName.get(i));
  598.             bf.append(" = ");
  599.             bf.append(this.updateFieldsValue.get(i));
  600.         }
  601.         bf.append(getSQL(false,true,false,false));
  602.         return bf.toString();
  603.     }

  605.     

  607.     
  608.     
  609.     /* ---------------- WHERE CONDITIONS ------------------ */
  610.     
  611.     @Override
  612.     public String createSQLConditionsEngine() throws SQLQueryObjectException {
  613.         
  614.         StringBuilder bf = new StringBuilder();
  615.         bf.append(getSQL(false,false,true,false));
  616.         return bf.toString();
  617.     }

  619.     

  621.     
  622.     
  623.     
  624.     
  625.     

  627. }
Created with JaCoCo 0.8.8.202204050719