GenericJDBCUtilities.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.  */
  20. package org.openspcoop2.generic_project.dao.jdbc.utils;


  23. import java.sql.Connection;
  24. import java.sql.Timestamp;
  25. import java.util.ArrayList;
  26. import java.util.Calendar;
  27. import java.util.Collection;
  28. import java.util.Date;
  29. import java.util.HashMap;
  30. import java.util.List;
  31. import java.util.Map;

  33. import org.openspcoop2.generic_project.beans.AliasField;
  34. import org.openspcoop2.generic_project.beans.ComplexField;
  35. import org.openspcoop2.generic_project.beans.Field;
  36. import org.openspcoop2.generic_project.beans.Function;
  37. import org.openspcoop2.generic_project.beans.FunctionField;
  38. import org.openspcoop2.generic_project.beans.IAliasTableField;
  39. import org.openspcoop2.generic_project.beans.IField;
  40. import org.openspcoop2.generic_project.beans.IModel;
  41. import org.openspcoop2.generic_project.beans.NonNegativeNumber;
  42. import org.openspcoop2.generic_project.beans.Union;
  43. import org.openspcoop2.generic_project.beans.UnionExpression;
  44. import org.openspcoop2.generic_project.beans.UnionOrderedColumn;
  45. import org.openspcoop2.generic_project.beans.UpdateField;
  46. import org.openspcoop2.generic_project.beans.UpdateModel;
  47. import org.openspcoop2.generic_project.dao.jdbc.IJDBCServiceSearchSingleObject;
  48. import org.openspcoop2.generic_project.dao.jdbc.IJDBCServiceSearchWithId;
  49. import org.openspcoop2.generic_project.dao.jdbc.IJDBCServiceSearchWithoutId;
  50. import org.openspcoop2.generic_project.dao.jdbc.JDBCExpression;
  51. import org.openspcoop2.generic_project.dao.jdbc.JDBCPaginatedExpression;
  52. import org.openspcoop2.generic_project.dao.jdbc.JDBCServiceManagerProperties;
  53. import org.openspcoop2.generic_project.exception.ExpressionException;
  54. import org.openspcoop2.generic_project.exception.ExpressionNotImplementedException;
  55. import org.openspcoop2.generic_project.exception.MultipleResultException;
  56. import org.openspcoop2.generic_project.exception.NotFoundException;
  57. import org.openspcoop2.generic_project.exception.NotImplementedException;
  58. import org.openspcoop2.generic_project.exception.ServiceException;
  59. import org.openspcoop2.generic_project.expression.IExpression;
  60. import org.openspcoop2.generic_project.expression.SortOrder;
  61. import org.openspcoop2.generic_project.expression.impl.OrderedField;
  62. import org.openspcoop2.generic_project.expression.impl.sql.ExpressionSQL;
  63. import org.openspcoop2.generic_project.expression.impl.sql.ISQLFieldConverter;
  64. import org.openspcoop2.utils.jdbc.JDBCAdapterException;
  65. import org.openspcoop2.utils.sql.ISQLQueryObject;
  66. import org.openspcoop2.utils.sql.SQLQueryObjectCore;
  67. import org.openspcoop2.utils.sql.SQLQueryObjectException;
  68. import org.slf4j.Logger;

  70. /**
  71.  * JDBCUtilities
  72.  * 
  73.  * @author Poli Andrea (apoli@link.it)
  74.  * @author $Author$
  75.  * @version $Rev$, $Date$
  76.  */
  77. public class GenericJDBCUtilities {

  79.     /* *** OTHER *** */
  80.     
  81.     public static void setFields(ISQLQueryObject sqlQueryObject,JDBCPaginatedExpression paginatedExpression, List<String> aliasField, IField ... field) throws ExpressionException{
  82.         setFields(sqlQueryObject, paginatedExpression, aliasField, true, field);
  83.     }
  84.     public static void setFields(ISQLQueryObject sqlQueryObject,JDBCPaginatedExpression paginatedExpression, List<String> aliasField, boolean appendTablePrefix , IField ... field) throws ExpressionException{
  85.         if(field!=null){
  86.             for (int i = 0; i < field.length; i++) {
  87.                 paginatedExpression.addField(sqlQueryObject, field[i], aliasField.get(i), appendTablePrefix);
  88.             }
  89.         }
  90.     }
  91.     public static void setFields(ISQLQueryObject sqlQueryObject,JDBCExpression expression, List<String> aliasField, IField ... field) throws ExpressionException{
  92.         setFields(sqlQueryObject, expression, aliasField, true, field);
  93.     }
  94.     public static void setFields(ISQLQueryObject sqlQueryObject,JDBCExpression expression, List<String> aliasField, boolean appendTablePrefix, IField ... field) throws ExpressionException{
  95.         if(field!=null){
  96.             for (int i = 0; i < field.length; i++) {
  97.                 expression.addField(sqlQueryObject, field[i], aliasField.get(i), appendTablePrefix);
  98.             }
  99.         }
  100.     }
  101.     
  102.     public static void setFields(ISQLQueryObject sqlQueryObject,JDBCPaginatedExpression paginatedExpression, IField ... field) throws ExpressionException{
  103.         setFields(sqlQueryObject, paginatedExpression, true, field);
  104.     }
  105.     public static void setFields(ISQLQueryObject sqlQueryObject,JDBCPaginatedExpression paginatedExpression, boolean appendTablePrefix, IField ... field) throws ExpressionException{
  106.         if(field!=null){
  107.             for (int i = 0; i < field.length; i++) {
  108.                 paginatedExpression.addField(sqlQueryObject, field[i], appendTablePrefix);
  109.             }
  110.         }
  111.     }
  112.     public static void setFields(ISQLQueryObject sqlQueryObject,JDBCExpression expression, IField ... field) throws ExpressionException{
  113.         setFields(sqlQueryObject, expression, true, field);
  114.     }
  115.     public static void setFields(ISQLQueryObject sqlQueryObject,JDBCExpression expression, boolean appendTablePrefix, IField ... field) throws ExpressionException{
  116.         if(field!=null){
  117.             for (int i = 0; i < field.length; i++) {
  118.                 expression.addField(sqlQueryObject, field[i], appendTablePrefix);
  119.             }
  120.         }
  121.     }
  122.     
  123.     public static void setAliasFields(ISQLQueryObject sqlQueryObject,JDBCPaginatedExpression paginatedExpression, IField ... field) throws ExpressionException{
  124.         setAliasFields(sqlQueryObject, paginatedExpression, true, field);
  125.     }
  126.     public static void setAliasFields(ISQLQueryObject sqlQueryObject,JDBCPaginatedExpression paginatedExpression, boolean appendTablePrefix, IField ... field) throws ExpressionException{
  127.         if(field!=null){
  128.             for (int i = 0; i < field.length; i++) {
  129.                 paginatedExpression.addAliasField(sqlQueryObject, field[i], appendTablePrefix);
  130.             }
  131.         }
  132.     }
  133.     public static void setAliasFields(ISQLQueryObject sqlQueryObject,JDBCExpression expression, IField ... field) throws ExpressionException{
  134.         setAliasFields(sqlQueryObject, expression, true, field);
  135.     }
  136.     public static void setAliasFields(ISQLQueryObject sqlQueryObject,JDBCExpression expression, boolean appendTablePrefix, IField ... field) throws ExpressionException{
  137.         if(field!=null){
  138.             for (int i = 0; i < field.length; i++) {
  139.                 expression.addAliasField(sqlQueryObject, field[i], appendTablePrefix);
  140.             }
  141.         }
  142.     }
  143.     
  144.     public static void removeFields(ISQLQueryObject sqlQueryObject,JDBCPaginatedExpression paginatedExpression, IField ... field) throws ExpressionException{
  145.         if(field!=null){
  146.             for (int i = 0; i < field.length; i++) {
  147.                 paginatedExpression.removeFieldManuallyAdd(field[i]);
  148.             }
  149.         }
  150.     }
  151.     public static void removeFields(ISQLQueryObject sqlQueryObject,JDBCExpression expression, IField ... field) throws ExpressionException{
  152.         if(field!=null){
  153.             for (int i = 0; i < field.length; i++) {
  154.                 expression.removeFieldManuallyAdd(field[i]);
  155.             }
  156.         }
  157.     }
  158.     
  159.     
  160.     public static void setFields(ISQLQueryObject sqlQueryObject,JDBCPaginatedExpression paginatedExpression, FunctionField ... functionField) throws ExpressionException{
  161.         setFields(sqlQueryObject, paginatedExpression, true, functionField);
  162.     }
  163.     public static void setFields(ISQLQueryObject sqlQueryObject,JDBCPaginatedExpression paginatedExpression, boolean appendTablePrefix, FunctionField ... functionField) throws ExpressionException{
  164.         if(functionField!=null){
  165.             for (int i = 0; i < functionField.length; i++) {
  166.                 paginatedExpression.addField(sqlQueryObject, functionField[i], appendTablePrefix);
  167.             }
  168.         }
  169.     }
  170.     public static void setFields(ISQLQueryObject sqlQueryObject,JDBCExpression expression, FunctionField ... functionField) throws ExpressionException{
  171.         setFields(sqlQueryObject, expression, true, functionField);
  172.     }
  173.     public static void setFields(ISQLQueryObject sqlQueryObject,JDBCExpression expression, boolean appendTablePrefix, FunctionField ... functionField) throws ExpressionException{
  174.         if(functionField!=null){
  175.             for (int i = 0; i < functionField.length; i++) {
  176.                 expression.addField(sqlQueryObject, functionField[i], appendTablePrefix);
  177.             }
  178.         }
  179.     }
  180.     
  181.     public static void removeFields(ISQLQueryObject sqlQueryObject,JDBCPaginatedExpression paginatedExpression, FunctionField ... functionField) throws ExpressionException{
  182.         if(functionField!=null){
  183.             for (int i = 0; i < functionField.length; i++) {
  184.                 paginatedExpression.removeFieldManuallyAdd(functionField[i]);
  185.             }
  186.         }
  187.     }
  188.     public static void removeFields(ISQLQueryObject sqlQueryObject,JDBCExpression expression, FunctionField ... functionField) throws ExpressionException{
  189.         if(functionField!=null){
  190.             for (int i = 0; i < functionField.length; i++) {
  191.                 expression.removeFieldManuallyAdd(functionField[i]);
  192.             }
  193.         }
  194.     }
  195.     
  196.     
  197.     
  198.     private static List<OrderedField> getOrderedFields(IExpression expression){
  199.         List<OrderedField> listOrderedFields = null;
  200.         if(expression instanceof JDBCPaginatedExpression){
  201.             listOrderedFields = ((JDBCPaginatedExpression)expression).getOrderedFields();
  202.         }
  203.         else if(expression instanceof JDBCExpression){
  204.             listOrderedFields = ((JDBCExpression)expression).getOrderedFields();
  205.         }
  206.         return listOrderedFields;
  207.     }
  208.     private static SortOrder getSortOrder(IExpression expression){
  209.         SortOrder sortOrder = null;
  210.         if(expression instanceof JDBCPaginatedExpression){
  211.             sortOrder = ((JDBCPaginatedExpression)expression).getSortOrder();
  212.         }
  213.         else if(expression instanceof JDBCExpression){
  214.             sortOrder = ((JDBCExpression)expression).getSortOrder();
  215.         }
  216.         return sortOrder;
  217.     }
  218.     
  219.     private static List<IField> getGroupByFields(IExpression expression){
  220.         List<IField> listGroupByFields = null;
  221.         if(expression instanceof JDBCPaginatedExpression){
  222.             listGroupByFields = ((JDBCPaginatedExpression)expression).getGroupByFields();
  223.         }
  224.         else if(expression instanceof JDBCExpression){
  225.             listGroupByFields = ((JDBCExpression)expression).getGroupByFields();
  226.         }
  227.         return listGroupByFields;
  228.     }
  229.     
  230.     private static boolean isUsedForCountExpression(IExpression expression){
  231.         boolean isUsed = false;
  232.         if(expression instanceof JDBCPaginatedExpression){
  233.             isUsed = ((JDBCPaginatedExpression)expression).isUsedForCountExpression();
  234.         }
  235.         else if(expression instanceof JDBCExpression){
  236.             isUsed = ((JDBCExpression)expression).isUsedForCountExpression();
  237.         }
  238.         return isUsed;
  239.     }
  240.     
  241.     private static void setUsedForCountExpression(IExpression expression, boolean value){
  242.         if(expression instanceof JDBCPaginatedExpression){
  243.             ((JDBCPaginatedExpression)expression).setUsedForCountExpression(value);
  244.         }
  245.         else if(expression instanceof JDBCExpression){
  246.             ((JDBCExpression)expression).setUsedForCountExpression(value);
  247.         }
  248.     }
  249.     
  250.     private static void toSqlForPreparedStatementWithFromCondition(IExpression expression,ISQLQueryObject sqlQueryObject,List<Object> listaQuery,String table) throws ExpressionException, ExpressionNotImplementedException{
  251.         if(expression instanceof JDBCPaginatedExpression){
  252.             ((JDBCPaginatedExpression)expression).toSqlForPreparedStatementWithFromCondition(sqlQueryObject,listaQuery,table);
  253.         }
  254.         else if(expression instanceof JDBCExpression){
  255.             ((JDBCExpression)expression).toSqlForPreparedStatementWithFromCondition(sqlQueryObject,listaQuery,table);
  256.         }
  257.     }
  258.     
  259.     private static List<Object> getFieldsManuallyAdd(IExpression expression) {
  260.         List<Object> list = null;
  261.         if(expression instanceof JDBCPaginatedExpression){
  262.             list = ((JDBCPaginatedExpression)expression).getFieldsManuallyAdd();
  263.         }
  264.         else if(expression instanceof JDBCExpression){
  265.             list = ((JDBCExpression)expression).getFieldsManuallyAdd();
  266.         }
  267.         return list;
  268.     }
  269.     
  270.     
  271.     public static NotFoundException newNotFoundException(){
  272.         return new NotFoundException("Not Found");
  273.     }
  274.     
  275.     public static NotImplementedException newNotImplementedException(){
  276.         return new NotImplementedException("NotImplemented");
  277.     }

  279.     
  280.     
  281.     
  282.     
  283.     
  284.     /* *** COUNT *** */
  285.     
  286.     public static List<Object> prepareCount(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,IExpression expression,
  287.             ISQLFieldConverter sqlConverter,IModel<?> model) throws SQLQueryObjectException, JDBCAdapterException, ExpressionException, ExpressionNotImplementedException, ServiceException{
  288.     
  289.         List<OrderedField> listOrderedFields = getOrderedFields(expression);
  290.         SortOrder sortOrder = getSortOrder(expression);
  291.         
  292.         if(listOrderedFields!=null && listOrderedFields.size()>0 && sortOrder!=null && !sortOrder.equals(SortOrder.UNSORTED)){
  293.             throw new ServiceException("OrderBy conditions not allowed in count expression");
  294.         }
  295.     
  296.         List<Object> listaQuery = new ArrayList<>();
  297.     
  298.         boolean oldValue = isUsedForCountExpression(expression);
  299.         setUsedForCountExpression(expression,true);
  300.         
  301.         try{
  302.         
  303.             toSqlForPreparedStatementWithFromCondition(expression,sqlQueryObject,listaQuery,
  304.                     sqlConverter.toTable(model));
  305.             
  306.             return listaQuery;
  307.         }finally{
  308.             setUsedForCountExpression(expression,oldValue);
  309.         }
  310.     }
  311.     
  312.     public static NonNegativeNumber count(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,IExpression expression,
  313.             ISQLFieldConverter sqlConverter,IModel<?> model,List<Object> listaQuery) throws SQLQueryObjectException, JDBCAdapterException, ExpressionException, ExpressionNotImplementedException, ServiceException{
  314.         long totale = 0;

  316.         // check group by per creare una ulteriore select count(*) from ( sql originale )
  317.         String sql = null;
  318.         List<IField> listGroupByFields = getGroupByFields(expression);
  319.         if(listGroupByFields!=null && listGroupByFields.size()>0){
  320.             
  321.             // serve per far aggiungere le colonne di group by all'espressione sqlQueryObject
  322.             for (IField iField : listGroupByFields) {
  323.                 sqlQueryObject.addSelectField(sqlConverter.toColumn(iField,true));
  324.             }
  325.             
  326.             ISQLQueryObject sqlCountGroup = sqlQueryObject.newSQLQueryObject();
  327.             sqlCountGroup.addSelectCountField("groupCount");
  328.             sqlCountGroup.addFromTable(sqlQueryObject);
  329.             
  330.             sql = sqlCountGroup.createSQLQuery();
  331.         }
  332.         else{
  333.             sql = sqlQueryObject.createSQLQuery();
  334.         }
  335.         
  336.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  337.                 new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);

  339.         JDBCObject[] params = new JDBCObject[listaQuery.size()];
  340.         int index = 0;
  341.         for (Object param : listaQuery) {
  342.             params[index++] = new JDBCObject(param, param.getClass());
  343.         }

  345.         totale = jdbcUtilities.count(sql, jdbcProperties.isShowSql(), params);

  347.         return new NonNegativeNumber(totale);
  348.     }
  349.     
  350.     
  351.     /* *** SELECT *** */
  352.     
  353.     public static List<Object> selectSingleObject(List<Map<String,Object>> map) throws NotFoundException {
  354.         if(map.size()<=0){
  355.             throw new NotFoundException("No result founds");
  356.         }
  357.         else{
  358.             List<Object> results = new ArrayList<>();
  359.             for(int i=0; i<map.size(); i++){
  360.                 results.add(map.get(i).values().iterator().next());     
  361.             }
  362.             return results;
  363.         }
  364.     }
  365.     
  366.     
  367.     /* *** AGGREGATE *** */
  368.     
  369.     public static Object selectAggregateObject(Map<String,Object> map,FunctionField functionField) throws NotFoundException {
  370.         if(map.size()<=0){
  371.             throw new NotFoundException("No result founds");
  372.         }
  373.         else{
  374.             return map.get(functionField.getAlias());
  375.         }
  376.     }
  377.     
  378.     
  379.     /* *** _SELECT *** */
  380.     
  381.     private static List<Object> toSqlForPreparedStatementFromCondition(IExpression expression,ISQLQueryObject sqlQueryObject,
  382.             List<Object> listaQuery,List<JDBCObject> params,ISQLFieldConverter sqlConverter,IModel<?> model) throws ExpressionException, ExpressionNotImplementedException{
  383.         
  384.         toSqlForPreparedStatementWithFromCondition(expression,sqlQueryObject,listaQuery,sqlConverter.toTable(model));
  385.         List<Object> returnField = getFieldsManuallyAdd(expression);
  386.         for (Object param : listaQuery) {
  387.             params.add( new JDBCObject(param, param.getClass()) );
  388.         }
  389.         
  390.         return returnField;
  391.     }
  392.     
  393.     private static List<Object> eliminaDuplicati(Collection<Object> returnField){
  394.         List<Object> listSenzaDuplicati = new ArrayList<>();
  395.         for (Object o : returnField) {
  396.             if(o instanceof IField){
  397.                 IField field = (IField) o;
  398.                 
  399.                 boolean found = false;
  400.                 for (Object check : listSenzaDuplicati) {
  401.                     if(check instanceof IField){
  402.                         IField iFieldCheck = (IField) check;
  403.                         if(iFieldCheck.equals(field)){
  404.                             // gia esiste
  405.                             found = true;
  406.                             break;
  407.                         }
  408.                     }
  409.                 }
  410.                 
  411.                 if(!found){
  412.                     listSenzaDuplicati.add(o);
  413.                 }
  414.             }
  415.             else if(o instanceof FunctionField){
  416.                 
  417.                 FunctionField field = (FunctionField) o;
  418.                 
  419.                 boolean found = false;
  420.                 for (Object check : listSenzaDuplicati) {
  421.                     if(check instanceof FunctionField){
  422.                         FunctionField functionFieldCheck = (FunctionField) check;
  423.                         if(functionFieldCheck.equals(field)){
  424.                             // gia esiste
  425.                             found = true;
  426.                             break;
  427.                         }
  428.                     }
  429.                 }
  430.                 
  431.                 if(!found){
  432.                     listSenzaDuplicati.add(o);
  433.                 }
  434.             
  435.             }
  436.         }
  437.         return listSenzaDuplicati;
  438.     }
  439.     
  440.     private static List<Class<?>> readClassTypes(Collection<Object> returnField){
  441.         List<Class<?>> returnClassTypes = new ArrayList<Class<?>>();
  442.         for (Object o : returnField) {
  443.             if(o instanceof IField){
  444.                 IField field = (IField) o;
  445.                 returnClassTypes.add(field.getFieldType());
  446.             }
  447.             else if(o instanceof FunctionField){
  448.                 FunctionField field = (FunctionField) o;
  449.                 if(field.getFieldType().toString().equals(Date.class.toString()) ||
  450.                         field.getFieldType().toString().equals(java.sql.Date.class.toString()) ||
  451.                         field.getFieldType().toString().equals(Timestamp.class.toString()) ||
  452.                         field.getFieldType().toString().equals(Calendar.class.toString())){
  453.                     returnClassTypes.add(Long.class);
  454.                 }
  455.                 else{
  456.                     returnClassTypes.add(field.getFieldType());
  457.                 }           
  458.             }
  459.         }
  460.         return returnClassTypes;
  461.     }
  462.     
  463.     private static List<List<String>> readAliases(Collection<Object> returnField) throws ServiceException{
  464.         
  465.         // inizializzo
  466.         List<List<String>> returnClassAliases = new ArrayList<List<String>>();
  467.         for (int i = 0; i < returnField.size(); i++) {
  468.             returnClassAliases.add(new ArrayList<>());
  469.         }
  470.         
  471.         // aggiungo i field semplici (foglie, vale per Field,ConstantField,CustomField,NullConstantField)
  472.         List<String> returnClassAliases_simple = new ArrayList<>();
  473.         int index = 0;
  474.         for (Object o : returnField) {
  475.             if(o instanceof Field){
  476.                 IField field = (IField) o;
  477.                 String nome = field.getFieldName();
  478.                 returnClassAliases_simple.add(nome);
  479.                 returnClassAliases.get(index).add(nome);
  480.             }
  481.             index++;
  482.         }
  483.         
  484.         // gestisco tutti gli oggetti
  485.         index = 0;
  486.         for (Object o : returnField) {
  487.             if(o instanceof IField){
  488.                 
  489.                 if(o instanceof AliasField){
  490.                     AliasField af = (AliasField) o;
  491.                     
  492.                     String nome = af.getAlias();
  493.                     if(returnClassAliases_simple.contains(nome)){
  494.                         throw new ServiceException("AliasField contains alias ["+nome+"] is already used for simple select field. Choose different alias name");
  495.                     }
  496.                     returnClassAliases.get(index).add(nome);
  497.                     
  498.                     IField field = af.getField();
  499.                     StringBuilder bf = new StringBuilder();
  500.                     buildAliasesPrefix(field,bf);
  501.                     String nomeField = bf.toString();
  502.                     if(!returnClassAliases_simple.contains(nome)){
  503.                         returnClassAliases.get(index).add(nomeField);
  504.                     }
  505.                 }
  506.                 else if(o instanceof IAliasTableField){
  507.                     StringBuilder bf = new StringBuilder();
  508.                     buildAliasesPrefix((IField)o,bf);
  509.                     returnClassAliases.get(index).add(bf.toString());
  510.                 }
  511.                 else if(o instanceof ComplexField){
  512.                     StringBuilder bf = new StringBuilder();
  513.                     buildAliasesPrefix((IField)o,bf);
  514.                     returnClassAliases.get(index).add(bf.toString());
  515.                 }

  517.             }
  518.             else if(o instanceof FunctionField){
  519.                 FunctionField field = (FunctionField) o;
  520.                 String nome = field.getAlias(); 
  521.                 if(returnClassAliases_simple.contains(nome)){
  522.                     throw new ServiceException("FunctionAliasName ["+nome+"] is already used for simple select field. Choose different alias name");
  523.                 }
  524.                 returnClassAliases.get(index).add(nome);
  525.             }
  526.             index++;
  527.         }

  529.         return returnClassAliases;
  530.     }
  531.     
  532.     public static String getAlias(Object object) throws ServiceException{
  533.         List<Object> l = new ArrayList<>();
  534.         l.add(object);
  535.         List<List<String>> ll = readAliases(l);
  536.         if( (ll==null) || ll.size()<=0){
  537.             throw new ServiceException("Build alias error");
  538.         }
  539.         if(ll.get(0)==null || ll.get(0).size()<=0){
  540.             throw new ServiceException("Build alias error (internal)");
  541.         }
  542.         return ll.get(0).get(0);
  543.     }
  544.     
  545.     private static void buildAliasesPrefix(IField field,StringBuilder prefix){
  546.         
  547.         if(field instanceof IAliasTableField){
  548.             prefix.append(((IAliasTableField)field).getAliasTable()).
  549.                 append(".").
  550.                 append(field.getFieldName());
  551.         }
  552.         else{
  553.         
  554.             if(field instanceof ComplexField){
  555.                 ComplexField c = (ComplexField) field;
  556.                 buildAliasesPrefix(c.getFather(), prefix);
  557.             }
  558.             
  559.             if(prefix.length()>0){
  560.                 prefix.append(".");
  561.             }
  562.             prefix.append(field.getFieldName());
  563.                 
  564.         }
  565.     }

  567.     public static List<Object> prepareSelect(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  568.             IExpression expression,ISQLFieldConverter sqlConverter,IModel<?> model,
  569.             List<Object> listaQuery,List<JDBCObject> listaParams) throws NotFoundException, ServiceException, SQLQueryObjectException, JDBCAdapterException, ExpressionException, ExpressionNotImplementedException{
  570.         
  571.         List<Object> returnField = 
  572.             org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.toSqlForPreparedStatementFromCondition(expression,sqlQueryObject,listaQuery,listaParams,
  573.                             sqlConverter,model);
  574.             
  575.         return returnField;
  576.     }
  577.         
  578.     public static ISQLQueryObject prepareSqlQueryObjectForSelectDistinct(boolean distinct, ISQLQueryObject sqlQueryObject, IExpression expression,
  579.             Logger log, ISQLFieldConverter sqlFieldConverter,IField ... field) throws SQLQueryObjectException, ExpressionException{
  580.         ISQLQueryObject sqlQueryObjectDistinct = null;
  581.         if(distinct){
  582.             
  583.             if(((SQLQueryObjectCore)sqlQueryObject).isSelectForUpdate()){
  584.                 throw new SQLQueryObjectException("Non è possibile abilitare il comando 'selectForUpdate' se viene utilizzata la clausola DISTINCT");
  585.             }
  586.             
  587.             sqlQueryObjectDistinct = sqlQueryObject.newSQLQueryObject();
  588.             JDBCPaginatedExpression paginatedExpressionTmp = new JDBCPaginatedExpression(sqlFieldConverter);
  589.             org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.setAliasFields(sqlQueryObjectDistinct,paginatedExpressionTmp,false,field);
  590.             sqlQueryObjectDistinct.setSelectDistinct(true);
  591.             List<OrderedField> listOrderedFields = getOrderedFields(expression);
  592.             SortOrder sortOrder = getSortOrder(expression);
  593.             if(listOrderedFields!=null &&  listOrderedFields.size()>0 &&
  594.                     sortOrder!=null &&
  595.                     !SortOrder.UNSORTED.equals(sortOrder)){
  596.                 boolean orderBy = false;
  597.                 for (OrderedField orderedFieldBean : listOrderedFields) {
  598.                     IField orderedField = orderedFieldBean.getField();
  599.                     boolean contains = false;
  600.                     for (int i = 0; i < field.length; i++) {
  601.                         if(orderedField.equals(field[i])){
  602.                             contains = true;
  603.                             break;
  604.                         }
  605.                     }
  606.                     if(contains){
  607.                         sqlQueryObjectDistinct.addOrderBy(sqlFieldConverter.toColumn(orderedField, false), SortOrder.ASC.equals(orderedFieldBean.getSortOrder()));
  608.                         orderBy = true;
  609.                     }
  610.                 }
  611.                 if(orderBy)
  612.                     sqlQueryObjectDistinct.setSortType(SortOrder.ASC.equals(sortOrder));
  613.             }
  614.         }
  615.         return sqlQueryObjectDistinct;
  616.     }
  617.     
  618.     public static ISQLQueryObject prepareSqlQueryObjectForSelectDistinct(ISQLQueryObject sqlQueryObject, ISQLQueryObject sqlQueryObjectDistinct) throws SQLQueryObjectException{
  619.         ISQLQueryObject sqlQueryObjectExecute = sqlQueryObject;
  620.         if(sqlQueryObjectDistinct!=null){
  621.             sqlQueryObjectDistinct.addFromTable(sqlQueryObject);
  622.             sqlQueryObjectExecute = sqlQueryObjectDistinct;
  623.         }
  624.         return sqlQueryObjectExecute;
  625.     }
  626.     
  627.     public static List<Map<String,Object>> select(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  628.             IExpression expression,ISQLFieldConverter sqlConverter,IModel<?> model,
  629.             List<Object> listaQuery,List<JDBCObject> listaParams, List<Object> returnField) throws NotFoundException, ServiceException, SQLQueryObjectException, JDBCAdapterException, ExpressionException, ExpressionNotImplementedException{
  630.         
  631.         // Se sono impostati groupBy, le condizioni di order by devono essere colonne definite anche nel group by
  632.         List<IField> listGroupByFields = getGroupByFields(expression);
  633.         if(listGroupByFields!=null && listGroupByFields.size()>0){
  634.             List<OrderedField> listOrderedFields = getOrderedFields(expression);
  635.             if(listOrderedFields!=null && listOrderedFields.size()>0){
  636.                 for (OrderedField orderedField : listOrderedFields) {
  637.                     IField iField = orderedField.getField();
  638.                     if(listGroupByFields.contains(iField)==false){
  639.                         throw new ServiceException("The field used for order by condition is invalid because it is not contained in GROUP BY clause. Field: ["+iField.toString()+"]");
  640.                     }
  641.                 }
  642.             }
  643.         }
  644.         
  645.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  646.                 new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);
  647.                 
  648.         String sql = sqlQueryObject.createSQLQuery();

  650.         JDBCObject[] params = null;
  651.         if(listaParams.size()>0){
  652.             params = listaParams.toArray(new JDBCObject[1]);
  653.         }
  654.         
  655.         returnField = eliminaDuplicati(returnField);
  656.         
  657.         List<Class<?>> returnClassTypes = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.readClassTypes(returnField);
  658.         List<List<String>> returnClassAliases = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.readAliases(returnField);
  659.                 
  660.         List<Map<String,Object>> result = new ArrayList<Map<String,Object>>();
  661.         
  662.         List<List<Object>> resultExecuteQuery = jdbcUtilities.executeQuery(sql, jdbcProperties.isShowSql(), returnClassTypes ,params);
  663.         if(resultExecuteQuery.size()>0){            
  664.             for (int i = 0; i < resultExecuteQuery.size(); i++) {
  665.                 List<Object> lista = resultExecuteQuery.get(i);
  666.                 if(lista==null){
  667.                     throw new ServiceException("Result["+i+"] is null?");
  668.                 }
  669.                 if(lista.size()!=returnField.size()){
  670.                     throw new ServiceException("Result["+i+"] has wrong length (expected:"+returnField.size()+" founded:"+lista.size()+")");
  671.                 }
  672.                 Map<String,Object> resultList = new HashMap<>();
  673.                 for (int j = 0; j < lista.size(); j++) {
  674.                     Object object = lista.get(j);
  675.                     for (String key : returnClassAliases.get(j)) {
  676.                         if(object!=null)
  677.                             resultList.put(key, object);
  678.                         else
  679.                             resultList.put(key, org.apache.commons.lang.ObjectUtils.NULL);  
  680.                     }
  681.                 }
  682.                 result.add(resultList);
  683.             }       
  684.         }
  685.         
  686.         if(result.size()<=0){
  687.             throw new NotFoundException("No result founds");
  688.         }
  689.         
  690.         return result;
  691.     }
  692.     
  693.     
  694.     /* *** UNION *** */
  695.     
  696.     public static List<Class<?>> checkUnionExpression(UnionExpression ... expression) throws ServiceException{
  697.         if(expression==null || expression.length<=0){
  698.             throw new ServiceException("UnionExpression not found");
  699.         }
  700.         if(expression.length==1){
  701.             throw new ServiceException("At least two expressions are required");
  702.         }
  703.         
  704.         List<Class<?>> listClassReturnType = new ArrayList<Class<?>>();
  705.         
  706.         for (int i = 0; i < expression.length; i++) {
  707.             
  708.             UnionExpression ue = expression[i];
  709.             List<String> aliasUe = ue.getReturnFieldAliases();
  710.             
  711.             if(aliasUe.size()<=0){
  712.                 throw new ServiceException("The expression n."+(i+1)+" contains no select field");
  713.             }
  714.             
  715.             // check with other expression
  716.             for (int j = 0; j < expression.length; j++) {
  717.                 if(j==i){
  718.                     continue;
  719.                 }
  720.                 UnionExpression checkUe = expression[j];
  721.                 List<String> checkAliasUe = checkUe.getReturnFieldAliases();
  722.                 
  723.                 if(checkAliasUe.size()<=0){
  724.                     throw new ServiceException("The expression n."+(j+1)+" contains no select field");
  725.                 }
  726.                 
  727.                 String errorMsg = "All expressions must contain the same number of select field with the same alias in the same order. ";
  728.                 
  729.                 if(checkAliasUe.size()!=aliasUe.size()){
  730.                     throw new ServiceException(errorMsg+"Found expression that contains a different number of select field ("+
  731.                                                 (i+1)+"-exp:"+aliasUe.size()+" "+(j+1)+"-exp:"+checkAliasUe.size()+")");
  732.                 }
  733.                 
  734.                 int index = 0;
  735.                 for (String checkAlias : checkAliasUe) {
  736.                     int index_interno = 0;
  737.                     for (String ueAlias : aliasUe) {
  738.                         if(index==index_interno){
  739.                             if(checkAlias.equals(ueAlias)==false){
  740.                                 throw new ServiceException(errorMsg+"Found expression that contains a different alias for select field n."+index+" ("+
  741.                                         (i+1)+"-exp alias:"+ueAlias+" "+(j+1)+"-exp alias:"+checkAlias+")");
  742.                             }
  743.                         }
  744.                         index_interno++;
  745.                     }
  746.                     index++;
  747.                 }
  748.                 
  749. //              index = 0;
  750. //              for (Object checkObject : checkObjectUe) {
  751. //                  int index_interno = 0;
  752. //                  for (Object ueObject : objectUe) {
  753. //                      if(index==index_interno){
  754.                             
  755.                             // TODO Eventuale check sui tipi, pero' non dovrebbe servire, e' il SQL stesso che darebbe errore.
  756. //                      }
  757. //                  }
  758. //              }
  759.                 
  760.             }
  761.             
  762.             if(i==0){
  763.                 // Uso i tipi della prima espressione. Dovrebbero essere tutti compatibili tra loro
  764.                 List<Object> listaObject = new ArrayList<>();
  765.                 for (String alias : aliasUe) {
  766.                     listaObject.add(ue.getReturnField(alias));
  767.                 }
  768.                 listClassReturnType = readClassTypes(listaObject);
  769.             }
  770.         }
  771.         return listClassReturnType;
  772.     }
  773.     
  774.     public static void checkUnionExpression(Union union,UnionExpression expressionComparator,ISQLQueryObject sqlQueryObject) throws ServiceException, SQLQueryObjectException{
  775.         
  776.         // Check select field
  777.         List<String> listaFields = union.getFields();
  778.         if(listaFields!=null && listaFields.size()>0){
  779.             
  780.             for (String alias : listaFields) {
  781.                 
  782.                 Function function = union.getFunction(alias);
  783.                 String paramAliasFunction = union.getParamAliasFunction(alias);
  784.                 String customFieldValue = union.getCustomFieldValue(alias);
  785.                 String aliasCheck = null;
  786.                 
  787.                 if(paramAliasFunction==null){
  788.                     // selezionato direttamente una colonna risultato delle espressioni interne
  789.                     // quando arrivo in questo metodo mi viene garantito dal metodo checkUnionExpression(expression ... )
  790.                     // che ogni espressione interna possiede lo stesso alias
  791.                 
  792.                     if(customFieldValue==null) {
  793.                         aliasCheck = alias;
  794.                     }
  795.                     //else non devo controllare l'alias poiche' potrebbe essere il risultato della combinazione degli elementi ritornati dalle espressioni union  
  796.                 }
  797.                 else{
  798.                     aliasCheck = paramAliasFunction;
  799.                 }
  800.                 
  801.                 if(aliasCheck!=null) {
  802.                     if(expressionComparator.getReturnFieldAliases()==null || !expressionComparator.getReturnFieldAliases().contains(aliasCheck)){
  803.                         throw new ServiceException("The alias ["+aliasCheck+"] is unknown. Check the alias used in the internal union expression");
  804.                     }
  805.                 }
  806.                 
  807.                 if(paramAliasFunction==null){
  808.                     if(customFieldValue==null) {
  809.                         sqlQueryObject.addSelectField(alias);
  810.                     }
  811.                     else {
  812.                         sqlQueryObject.addSelectAliasField(customFieldValue, alias);
  813.                     }
  814.                 }else{
  815.                     ExpressionSQL.setFunction(function, false, paramAliasFunction, alias, sqlQueryObject);
  816.                 }
  817.             }

  819.         }
  820.         
  821.         // Check eventuali group by siano alias che corrispondano ad alias reali
  822.         if(union.getGroupByList()!=null && union.getGroupByList().size()>0){
  823.             List<String> aliasExpression = expressionComparator.getReturnFieldAliases();
  824.             for (String aliasGroupBy : union.getGroupByList()) {
  825.                 if(aliasExpression.contains(aliasGroupBy)==false){
  826.                     throw new ServiceException("The alias used in the condition of group by the union must be one of the aliases used in internal expressions");
  827.                 }
  828.                 sqlQueryObject.addGroupBy(aliasGroupBy);
  829.             }
  830.         }
  831.         
  832.         // Check eventuali order by siano alias che corrispondano ad alias reali
  833.         if(union.getOrderByList()!=null && union.getOrderByList().size()>0){
  834.             SortOrder sortOrderUnion = null;
  835.             try{
  836.                 sortOrderUnion = union.getSortOrder();
  837.             }catch(Exception e){
  838.                 throw new ServiceException(e.getMessage(),e);
  839.             }
  840.             if(!SortOrder.UNSORTED.equals(sortOrderUnion)){
  841.                 List<String> aliasExpression = expressionComparator.getReturnFieldAliases();
  842.                 List<String> aliasExternalExpression = union.getFields();
  843.                 for (UnionOrderedColumn uoo : union.getOrderByList()) {
  844.                     String aliasOrderBy = uoo.getAlias();
  845.                     SortOrder sortOrder = uoo.getSortOrder();
  846.                     if(aliasExpression.contains(aliasOrderBy)==false && aliasExternalExpression.contains(aliasOrderBy)==false){
  847.                         throw new ServiceException("The alias '"+aliasOrderBy+"' used in the condition of order by the union must be one of the aliases used in internal or external expressions");
  848.                     }
  849.                     if(sortOrder==null){
  850.                         sqlQueryObject.addOrderBy(aliasOrderBy);
  851.                     }
  852.                     else{
  853.                         sqlQueryObject.addOrderBy(aliasOrderBy,SortOrder.ASC.equals(sortOrder));
  854.                     }
  855.                 }
  856.                 sqlQueryObject.setSortType(SortOrder.ASC.equals(sortOrderUnion));
  857.             }
  858.         }
  859.         
  860.         // Check Limit/Offset
  861.         if(union.getLimit()!=null){
  862.             sqlQueryObject.setLimit(union.getLimit());
  863.         }
  864.         if(union.getOffset()!=null){
  865.             sqlQueryObject.setOffset(union.getOffset());
  866.         }
  867.         
  868.     }
  869.     
  870.     protected static void setFields(List<ISQLQueryObject> sqlQueryObjectInnerList,UnionExpression ... unionExpression) throws ExpressionException, ServiceException{
  871.         manageFields(sqlQueryObjectInnerList, true, false, unionExpression);
  872.     }
  873.     protected static void removeFields(List<ISQLQueryObject> sqlQueryObjectInnerList,UnionExpression ... unionExpression) throws ExpressionException, ServiceException{
  874.         manageFields(sqlQueryObjectInnerList, false, true, unionExpression);
  875.     }
  876.     private static void manageFields(List<ISQLQueryObject> sqlQueryObjectInnerList,boolean set,boolean remove,UnionExpression ... unionExpression) throws ExpressionException, ServiceException{
  877.         if(unionExpression==null || unionExpression.length<=0){
  878.             throw new ServiceException("UnionExpression not found");
  879.         }
  880.         if(unionExpression.length==1){
  881.             throw new ServiceException("At least two expressions are required");
  882.         }
  883.         
  884.         for (int i = 0; i < unionExpression.length; i++) {
  885.             
  886.             ISQLQueryObject sqlQueryObject = sqlQueryObjectInnerList.get(i);
  887.             
  888.             UnionExpression ue = unionExpression[i];
  889.             IExpression exp = ue.getExpression();
  890. //          List<IField> listField = new ArrayList<IField>();
  891. //          List<FunctionField> listFunctionField = new ArrayList<FunctionField>();     
  892.             List<String> aliasUE = ue.getReturnFieldAliases();
  893.             for (String alias : aliasUE) {
  894.                 Object o = ue.getReturnField(alias);
  895.                 if(o instanceof IField){
  896.                     IField field = (IField) o;
  897.                     //listField.add(field);
  898.                     
  899.                     if(set){
  900.                         List<String> lAlias = new ArrayList<>();
  901.                         lAlias.add(alias);
  902.                         if(exp instanceof JDBCExpression){
  903.                             setFields(sqlQueryObject, ((JDBCExpression)exp), lAlias, field);
  904.                         }else{
  905.                             setFields(sqlQueryObject, ((JDBCPaginatedExpression)exp), lAlias, field);
  906.                         }
  907.                     }
  908.                     else{
  909.                         if(exp instanceof JDBCExpression){
  910.                             removeFields(sqlQueryObject, ((JDBCExpression)exp), field);
  911.                         }else{
  912.                             removeFields(sqlQueryObject, ((JDBCPaginatedExpression)exp), field);
  913.                         }
  914.                     }
  915.                     
  916.                 }
  917.                 else if(o instanceof FunctionField){
  918.                     FunctionField field = (FunctionField) o;
  919.                     //listFunctionField.add(field);     
  920.                     
  921.                     if(set){
  922.                         if(exp instanceof JDBCExpression){
  923.                             setFields(sqlQueryObject, ((JDBCExpression)exp), field);
  924.                         }else{
  925.                             setFields(sqlQueryObject, ((JDBCPaginatedExpression)exp), field);
  926.                         }
  927.                     }
  928.                     else{
  929.                         if(exp instanceof JDBCExpression){
  930.                             removeFields(sqlQueryObject, ((JDBCExpression)exp), field);
  931.                         }else{
  932.                             removeFields(sqlQueryObject, ((JDBCPaginatedExpression)exp), field);
  933.                         }
  934.                     }
  935.                 }
  936.             }
  937.             
  938.             /*
  939.             IField[] fields = null;
  940.             if(listField.size()>0){
  941.                 fields = listField.toArray(new IField[1]);
  942.             }
  943.             if(set){
  944.                 if(exp instanceof JDBCExpression){
  945.                     setFields(sqlQueryObject, ((JDBCExpression)exp), aliasUe, fields);
  946.                 }else{
  947.                     setFields(sqlQueryObject, ((JDBCPaginatedExpression)exp), aliasUe, fields);
  948.                 }
  949.             }
  950.             else{
  951.                 if(exp instanceof JDBCExpression){
  952.                     removeFields(sqlQueryObject, ((JDBCExpression)exp), fields);
  953.                 }else{
  954.                     removeFields(sqlQueryObject, ((JDBCPaginatedExpression)exp), fields);
  955.                 }
  956.             }
  957.             
  958.             FunctionField[] functionFields = null;
  959.             if(listFunctionField.size()>0){
  960.                 functionFields = listFunctionField.toArray(new FunctionField[1]);
  961.             }
  962.             if(set){
  963.                 if(exp instanceof JDBCExpression){
  964.                     setFields(sqlQueryObject, ((JDBCExpression)exp), functionFields);
  965.                 }else{
  966.                     setFields(sqlQueryObject, ((JDBCPaginatedExpression)exp), functionFields);
  967.                 }
  968.             }
  969.             else{
  970.                 if(exp instanceof JDBCExpression){
  971.                     removeFields(sqlQueryObject, ((JDBCExpression)exp), functionFields);
  972.                 }else{
  973.                     removeFields(sqlQueryObject, ((JDBCPaginatedExpression)exp), functionFields);
  974.                 }
  975.             }
  976.             */
  977.         }
  978.     }
  979.     
  980.     public static List<Class<?>> prepareUnion(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  981.             ISQLFieldConverter sqlConverter,IModel<?> model,
  982.             List<ISQLQueryObject> sqlQueryObjectInnerList,List<JDBCObject> jdbcObjects,
  983.             Union union,UnionExpression ... unionExpression) throws NotFoundException, ExpressionException, ExpressionNotImplementedException, SQLQueryObjectException, JDBCAdapterException, ServiceException{
  984.             
  985.         if(sqlQueryObject==null) {
  986.             throw new SQLQueryObjectException("sqlQueryObject parameter is null");
  987.         }
  988.         if(sqlConverter==null) {
  989.             throw new SQLQueryObjectException("sqlConverter parameter is null");
  990.         }
  991.         if(model==null) {
  992.             throw new SQLQueryObjectException("model parameter is null");
  993.         }
  994.         if(sqlQueryObjectInnerList==null) {
  995.             throw new SQLQueryObjectException("sqlQueryObjectInnerList parameter is null");
  996.         }
  997.         if(jdbcObjects==null) {
  998.             throw new SQLQueryObjectException("jdbcObjects parameter is null");
  999.         }
  1000.         if(union==null) {
  1001.             throw new SQLQueryObjectException("union parameter is null");
  1002.         }
  1003.         if(unionExpression==null) {
  1004.             throw new SQLQueryObjectException("unionExpression parameter is null");
  1005.         }
  1006.         
  1007.         // check expression
  1008.         List<Class<?>> returnClassTypes = checkUnionExpression(unionExpression);
  1009.     
  1010.         // check union external expression
  1011.         // quando arrivo in questo metodo mi viene garantito dal metodo checkUnionExpression(expression ... )
  1012.         // che ogni espressione interna possiede lo stesso alias e che cmq esistano almeno 2 espressioni
  1013.         checkUnionExpression(union,unionExpression[0],sqlQueryObject);
  1014.         
  1015.         // set fields in expression
  1016.         for (int i = 0; i < unionExpression.length; i++) {
  1017.             ISQLQueryObject sqlQueryObjectInner = sqlQueryObject.newSQLQueryObject();
  1018.             sqlQueryObjectInner.setANDLogicOperator(true);
  1019.             sqlQueryObjectInnerList.add(sqlQueryObjectInner);
  1020.             //System.out.println("UE["+i+"]: "+unionExpression[i].getReturnFieldAliases());
  1021.         }
  1022.         setFields(sqlQueryObjectInnerList, unionExpression);
  1023. //      if(sqlQueryObjectInnerList.size()==2) {
  1024. //          System.out.println("SET FIELDS AAAAAAAAAAAAA: "+sqlQueryObjectInnerList.size());
  1025. //          System.out.println("SET FIELDS AAAAAAAAAAAAA [0]="+sqlQueryObjectInnerList.get(0).getFieldsName());
  1026. //          System.out.println("SET FIELDS AAAAAAAAAAAAA [1]="+sqlQueryObjectInnerList.get(1).getFieldsName());
  1027. //      }
  1028.         // non serve il remove,  SONO SQL FIELD CREATI INTERNAMENTE
  1029.         
  1030.         // Create sql query object
  1031.         for (int i = 0; i < unionExpression.length; i++) {

  1033.             IExpression expr = unionExpression[i].getExpression();
  1034.             
  1035.             ISQLQueryObject sqlQueryObjectInner = sqlQueryObjectInnerList.get(i);
  1036.             
  1037.             List<Object> listaQuery = new ArrayList<>();
  1038.             toSqlForPreparedStatementWithFromCondition(expr,sqlQueryObjectInner,listaQuery,sqlConverter.toTable(model));
  1039.             for (Object param : listaQuery) {
  1040.                 jdbcObjects.add(new JDBCObject(param, param.getClass()));
  1041.             }
  1042.             
  1043.         }
  1044.         
  1045. //      if(sqlQueryObjectInnerList.size()==2) {
  1046. //          System.out.println("DOPO AAAAAAAAAAAAA: "+sqlQueryObjectInnerList.size());
  1047. //          System.out.println("DOPO AAAAAAAAAAAAA [0]="+sqlQueryObjectInnerList.get(0).getFieldsName());
  1048. //          System.out.println("DOPO AAAAAAAAAAAAA [1]="+sqlQueryObjectInnerList.get(1).getFieldsName());
  1049. //      }
  1050.         
  1051.         return returnClassTypes;
  1052.     }
  1053.         
  1054.     public static List<Map<String,Object>> union(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  1055.             ISQLFieldConverter sqlConverter,IModel<?> model,
  1056.             List<ISQLQueryObject> sqlQueryObjectInnerList,List<JDBCObject> jdbcObjects, List<Class<?>> returnClassTypes,
  1057.             Union union,UnionExpression ... unionExpression) throws NotFoundException, ExpressionException, ExpressionNotImplementedException, SQLQueryObjectException, JDBCAdapterException, ServiceException{
  1058.                     
  1059.         if(jdbcProperties==null) {
  1060.             throw new ServiceException("jdbcProperties is null");
  1061.         }
  1062.         if(sqlQueryObject==null) {
  1063.             throw new ServiceException("sqlQueryObject is null");
  1064.         }
  1065.         if(sqlQueryObjectInnerList==null) {
  1066.             throw new ServiceException("sqlQueryObjectInnerList is null");
  1067.         }
  1068.         if(jdbcObjects==null) {
  1069.             throw new ServiceException("jdbcObjects is null");
  1070.         }
  1071.         if(returnClassTypes==null) {
  1072.             throw new ServiceException("returnClassTypes is null");
  1073.         }
  1074.         if(union==null) {
  1075.             throw new ServiceException("union is null");
  1076.         }
  1077.         if(unionExpression==null) {
  1078.             throw new ServiceException("unionExpression is null");
  1079.         }
  1080.         
  1081.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  1082.             new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);
  1083.         
  1084.         // Aggiunto un livello intermedio agli inner sql, in modo da essere sicuro di avere gli alias nei select field.
  1085.         // !non serve!
  1086. //      List<ISQLQueryObject> sqlQueryObjectUnionExpression = new ArrayList<>();
  1087. //      for (int i = 0; i < unionExpression.length; i++) {
  1088. //          ISQLQueryObject sqlQueryObjectUnion = sqlQueryObject.newSQLQueryObject(); 
  1089. //          for (String alias : unionExpression[i].getReturnFieldAliases()) {
  1090. //              sqlQueryObjectUnion.addSelectField(alias);
  1091. //          }
  1092. //          sqlQueryObjectUnion.addFromTable(sqlQueryObjectInnerList.get(i));
  1093. //          sqlQueryObjectUnionExpression.add(sqlQueryObjectUnion);
  1094. //      }
  1095.         
  1096.         // Create and execute sql union
  1097.         //String sql = sqlQueryObject.createSQLUnion(union.isUnionAll(), sqlQueryObjectUnionExpression.toArray(new ISQLQueryObject[1]));
  1098.         String sql = sqlQueryObject.createSQLUnion(union.isUnionAll(), sqlQueryObjectInnerList.toArray(new ISQLQueryObject[1]));
  1099.                 
  1100.         // Per gli alias uso quelli della prima espressione, tanto nel check ho verificato che siano identici a meno di non averli ridefiniti nella union esterna.
  1101.         List<String> returnClassAliases = unionExpression[0].getReturnFieldAliases();
  1102.         if(union.getFields()!=null && union.getFields().size()>0){
  1103.             returnClassAliases = union.getFields();
  1104.         }
  1105.         
  1106.         // Eseguo la query
  1107.         List<Map<String,Object>> result = new ArrayList<Map<String,Object>>();
  1108.         
  1109.         JDBCObject [] params = null;
  1110.         if(jdbcObjects.size()>0)
  1111.             params = jdbcObjects.toArray(new JDBCObject[1]);
  1112.         List<List<Object>> resultExecuteQuery = jdbcUtilities.executeQuery(sql, jdbcProperties.isShowSql(), returnClassTypes ,params);
  1113.         if(resultExecuteQuery.size()>0){            
  1114.             for (int i = 0; i < resultExecuteQuery.size(); i++) {
  1115.                 List<Object> lista = resultExecuteQuery.get(i);
  1116.                 if(lista==null){
  1117.                     throw new ServiceException("Result["+i+"] is null?");
  1118.                 }
  1119.                 if(lista.size()!=returnClassTypes.size()){
  1120.                     throw new ServiceException("Result["+i+"] has wrong length (expected:"+returnClassTypes.size()+" founded:"+lista.size()+")");
  1121.                 }
  1122.                 // controllo seguente non dovrebbe servire... 
  1123.                 if(lista.size()!=returnClassAliases.size()){
  1124.                     throw new ServiceException("Result["+i+"] has wrong length (alias) (expected:"+returnClassAliases.size()+" founded:"+lista.size()+")");
  1125.                 }
  1126.                 Map<String,Object> resultList = new HashMap<>();
  1127.                 int j = 0;
  1128.                 for (String alias : returnClassAliases) {
  1129.                     Object object = lista.get(j);
  1130.                     if(object!=null)
  1131.                         resultList.put(alias, object);
  1132.                     else
  1133.                         resultList.put(alias, org.apache.commons.lang.ObjectUtils.NULL);
  1134.                     j++;
  1135.                 }
  1136.                 result.add(resultList);
  1137.             }       
  1138.         }
  1139.         
  1140.         if(result.size()<=0){
  1141.             throw new NotFoundException("No result founds");
  1142.         }
  1143.         
  1144.         return result;
  1145.             
  1146.     }
  1147.     
  1148.     
  1149.     /* *** UNION COUNT *** */
  1150.     
  1151.     public static List<Class<?>> prepareUnionCount(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  1152.             ISQLFieldConverter sqlConverter,IModel<?> model,
  1153.             List<ISQLQueryObject> sqlQueryObjectInnerList,List<JDBCObject> jdbcObjects,
  1154.             Union union,UnionExpression ... unionExpression) throws NotFoundException, ExpressionException, ExpressionNotImplementedException, SQLQueryObjectException, JDBCAdapterException, ServiceException{
  1155.     
  1156.         if(union.getOrderByList().size()>0 && union.getSortOrder()!=null && !union.getSortOrder().equals(SortOrder.UNSORTED)){
  1157.             throw new ServiceException("OrderBy conditions not allowed in count expression");
  1158.         }
  1159.         if(union.getOffset()!=null){
  1160.             throw new ServiceException("Offset condition not allowed in count expression");
  1161.         }
  1162.         if(union.getLimit()!=null){
  1163.             throw new ServiceException("Limit condition not allowed in count expression");
  1164.         }
  1165.         
  1166.         return prepareUnion(jdbcProperties, log, connection, sqlQueryObject, sqlConverter, model, sqlQueryObjectInnerList, jdbcObjects, union, unionExpression);
  1167.         
  1168.     }
  1169.     
  1170.     public static NonNegativeNumber unionCount(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  1171.             ISQLFieldConverter sqlConverter,IModel<?> model,
  1172.             List<ISQLQueryObject> sqlQueryObjectInnerList,List<JDBCObject> jdbcObjects, List<Class<?>> returnClassTypes,
  1173.             Union union,UnionExpression ... unionExpression) throws NotFoundException, ExpressionException, ExpressionNotImplementedException, SQLQueryObjectException, JDBCAdapterException, ServiceException{
  1174.                     
  1175.         long totale = 0;
  1176.         
  1177.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  1178.             new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);
  1179.         
  1180.         // Create and execute sql union
  1181.         String sql = sqlQueryObject .createSQLUnionCount(union.isUnionAll(), "unionCount" , sqlQueryObjectInnerList.toArray(new ISQLQueryObject[1]));
  1182.         
  1183.         JDBCObject [] params = null;
  1184.         if(jdbcObjects.size()>0)
  1185.             params = jdbcObjects.toArray(new JDBCObject[1]);
  1186.         
  1187.         totale = jdbcUtilities.count(sql, jdbcProperties.isShowSql(), params);

  1189.         return new NonNegativeNumber(totale);
  1190.             
  1191.     }
  1192.     
  1193.     
  1194.     /* *** FIND ALL *** */
  1195.     
  1196.     public static List<Object> prepareFindAll(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  1197.             IExpression paginatedExpression,ISQLFieldConverter sqlConverter,IModel<?> model) throws SQLQueryObjectException, JDBCAdapterException, ExpressionException, ExpressionNotImplementedException, ServiceException{
  1198.     
  1199.         List<Object> listaQuery = new ArrayList<>();
  1200.         
  1201.         toSqlForPreparedStatementWithFromCondition(paginatedExpression,sqlQueryObject,listaQuery,
  1202.                 sqlConverter.toTable(model));
  1203.         
  1204.         return listaQuery;
  1205.     }
  1206.     
  1207.     public static List<Object> findAll(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  1208.             IExpression paginatedExpression,ISQLFieldConverter sqlConverter,IModel<?> model,Class<?> objectIdClass,List<Object> listaQuery) throws SQLQueryObjectException, JDBCAdapterException, ExpressionException, ExpressionNotImplementedException, ServiceException{
  1209.         
  1210.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  1211.                 new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);

  1213.         JDBCObject[] params = new JDBCObject[listaQuery.size()];
  1214.         int index = 0;
  1215.         for (Object param : listaQuery) {
  1216.             params[index++] = new JDBCObject(param, param.getClass());
  1217.         }
  1218.         
  1219.         String sql = sqlQueryObject.createSQLQuery();

  1221.         return jdbcUtilities.executeQuery(sql, jdbcProperties.isShowSql(), objectIdClass, params);
  1222.     }
  1223.     
  1224.     public static List<List<Object>> findAll(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  1225.             IExpression paginatedExpression,ISQLFieldConverter sqlConverter,IModel<?> model,List<Class<?>> objectIdsClass,List<Object> listaQuery) throws SQLQueryObjectException, JDBCAdapterException, ExpressionException, ExpressionNotImplementedException, ServiceException{
  1226.         
  1227.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  1228.                 new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);

  1230.         JDBCObject[] params = new JDBCObject[listaQuery.size()];
  1231.         int index = 0;
  1232.         for (Object param : listaQuery) {
  1233.             params[index++] = new JDBCObject(param, param.getClass());
  1234.         }
  1235.         
  1236.         String sql = sqlQueryObject.createSQLQuery();

  1238.         return jdbcUtilities.executeQuery(sql, jdbcProperties.isShowSql(), objectIdsClass, params);
  1239.     }
  1240.     
  1241.     
  1242.     /* *** FIND *** */
  1243.     
  1244.     public static List<Object> prepareFind(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  1245.             IExpression expression,ISQLFieldConverter sqlConverter,IModel<?> model) throws SQLQueryObjectException, JDBCAdapterException, ExpressionException, ExpressionNotImplementedException, ServiceException, MultipleResultException{
  1246.     
  1247.         List<Object> listaQuery = new ArrayList<>();
  1248.         
  1249.         toSqlForPreparedStatementWithFromCondition(expression,sqlQueryObject,listaQuery,
  1250.                 sqlConverter.toTable(model));
  1251.         
  1252.         return listaQuery;
  1253.     }
  1254.     
  1255.     public static Object find(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  1256.             IExpression expression,ISQLFieldConverter sqlConverter,IModel<?> model,Class<?> objectIdClass,List<Object> listaQuery) throws SQLQueryObjectException, JDBCAdapterException, ExpressionException, ExpressionNotImplementedException, NotFoundException, ServiceException, MultipleResultException{
  1257.         
  1258.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  1259.                 new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);

  1261.         JDBCObject[] params = new JDBCObject[listaQuery.size()];
  1262.         int index = 0;
  1263.         for (Object param : listaQuery) {
  1264.             params[index++] = new JDBCObject(param, param.getClass());
  1265.         }
  1266.         
  1267.         String sql = sqlQueryObject.createSQLQuery();

  1269.         return jdbcUtilities.executeQuerySingleResult(sql, jdbcProperties.isShowSql(), objectIdClass, params);
  1270.     }
  1271.     
  1272.     public static List<Object> find(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  1273.             IExpression expression,ISQLFieldConverter sqlConverter,IModel<?> model,List<Class<?>> objectIdsClass,List<Object> listaQuery) throws SQLQueryObjectException, JDBCAdapterException, ExpressionException, ExpressionNotImplementedException, NotFoundException, ServiceException, MultipleResultException{
  1274.         
  1275.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  1276.                 new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);

  1278.         JDBCObject[] params = new JDBCObject[listaQuery.size()];
  1279.         int index = 0;
  1280.         for (Object param : listaQuery) {
  1281.             params[index++] = new JDBCObject(param, param.getClass());
  1282.         }
  1283.         
  1284.         String sql = sqlQueryObject.createSQLQuery();

  1286.         return jdbcUtilities.executeQuerySingleResult(sql, jdbcProperties.isShowSql(), objectIdsClass, params);
  1287.     }
  1288.     
  1289.     
  1290.     
  1291.     /* *** UPDATE  ** */

  1293.     public static void updateFields(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  1294.             String rootTable, Map<String, List<IField>> mapTableToPKColumn, List<Object> rootTableIdValues,
  1295.             ISQLFieldConverter sqlConverter,
  1296.             IJDBCServiceSearchSingleObject<?, ?> serviceSingleObject,
  1297.             UpdateModel ... updateModels) throws ServiceException, NotImplementedException, Exception{
  1298.         updateFields(jdbcProperties, log, connection, sqlQueryObject, rootTable, mapTableToPKColumn, rootTableIdValues, sqlConverter, 
  1299.                 serviceSingleObject, null, null, updateModels);
  1300.     }
  1301.     public static void updateFields(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  1302.             String rootTable, Map<String, List<IField>> mapTableToPKColumn, List<Object> rootTableIdValues,
  1303.             ISQLFieldConverter sqlConverter,
  1304.             IJDBCServiceSearchWithId<?, ?, ?> serviceWithId,
  1305.             UpdateModel ... updateModels) throws ServiceException, NotImplementedException, Exception{
  1306.         updateFields(jdbcProperties, log, connection, sqlQueryObject, rootTable, mapTableToPKColumn, rootTableIdValues, sqlConverter, 
  1307.                 null, serviceWithId, null, updateModels);
  1308.     }
  1309.     public static void updateFields(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  1310.             String rootTable, Map<String, List<IField>> mapTableToPKColumn, List<Object> rootTableIdValues,
  1311.             ISQLFieldConverter sqlConverter,
  1312.             IJDBCServiceSearchWithoutId<?, ?> serviceWithoutId,
  1313.             UpdateModel ... updateModels) throws ServiceException, NotImplementedException, Exception{
  1314.         updateFields(jdbcProperties, log, connection, sqlQueryObject, rootTable, mapTableToPKColumn, rootTableIdValues, sqlConverter, 
  1315.                 null, null, serviceWithoutId, updateModels);
  1316.     }
  1317.     
  1318.     private static void updateFields(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  1319.             String rootTable, Map<String, List<IField>> mapTableToPKColumn, List<Object> rootTableIdValues,
  1320.             ISQLFieldConverter sqlConverter,
  1321.             IJDBCServiceSearchSingleObject<?, ?> serviceSingleObject,
  1322.             IJDBCServiceSearchWithId<?, ?, ?> serviceWithId,
  1323.             IJDBCServiceSearchWithoutId<?, ?> serviceWithoutId,
  1324.             UpdateModel ... updateModels) throws ServiceException, NotImplementedException, Exception{
  1325.         
  1326.         if(updateModels==null || updateModels.length<=0){
  1327.             throw new ServiceException("Parameter updateModels is not defined");
  1328.         }
  1329.         List<String> tableUpdated = new ArrayList<>();
  1330.         for (UpdateModel updateModel : updateModels) {
  1331.             
  1332.             IModel<?> model = updateModel.getModel();
  1333.             IExpression condition = updateModel.getCondition();
  1334.             List<UpdateField> updateFields = updateModel.getUpdateFiels();
  1335.             if(updateFields==null || updateFields.size()<=0){
  1336.                 throw new ServiceException("Parameter updateFields of model ["+model+"] is not defined");
  1337.             }
  1338.             String table = sqlConverter.toTable(model);
  1339.             if(table==null){
  1340.                 throw new ServiceException("Model ["+model+"] is not defined in sql converter");
  1341.             }
  1342.             for (UpdateField updateField : updateFields) {
  1343.                 String tableField = sqlConverter.toTable(updateField.getField());
  1344.                 if(table.equals(tableField)==false){
  1345.                     throw new ServiceException("Different update table: UpdateField ["+updateField.getField().getFieldName()+" of "+updateField.getField().getClassName()+"] (table:"+tableField+") and Model ["+model+"] (table:"+table+") ");
  1346.                 }
  1347.             }
  1348.             if(tableUpdated.contains(table)==false){
  1349.                 
  1350.                 _engineUpdateFields(jdbcProperties, log, connection, sqlQueryObject, sqlConverter, serviceSingleObject, 
  1351.                         serviceWithId, serviceWithoutId, rootTable, mapTableToPKColumn, rootTableIdValues, table, condition, updateFields);
  1352.                 tableUpdated.add(table);
  1353.             }
  1354.                     
  1355.         }
  1356.         
  1357.     }
  1358.     
  1359.     public static void updateFields(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  1360.             String rootTable, Map<String, List<IField>> mapTableToPKColumn, List<Object> rootTableIdValues,
  1361.             ISQLFieldConverter sqlConverter,
  1362.             IJDBCServiceSearchSingleObject<?, ?> serviceSingleObject,
  1363.             IExpression condition, UpdateField ... updateFields) throws ServiceException, NotImplementedException, Exception{
  1364.         updateFields(jdbcProperties, log, connection, sqlQueryObject, rootTable, mapTableToPKColumn, rootTableIdValues, sqlConverter, 
  1365.                 serviceSingleObject, null, null, condition, updateFields);
  1366.     }
  1367.     public static void updateFields(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  1368.             String rootTable, Map<String, List<IField>> mapTableToPKColumn, List<Object> rootTableIdValues,
  1369.             ISQLFieldConverter sqlConverter,
  1370.             IJDBCServiceSearchWithId<?, ?, ?> serviceWithId,
  1371.             IExpression condition, UpdateField ... updateFields) throws ServiceException, NotImplementedException, Exception{
  1372.         updateFields(jdbcProperties, log, connection, sqlQueryObject, rootTable, mapTableToPKColumn, rootTableIdValues, sqlConverter, 
  1373.                 null, serviceWithId, null, condition, updateFields);
  1374.     }
  1375.     public static void updateFields(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  1376.             String rootTable, Map<String, List<IField>> mapTableToPKColumn, List<Object> rootTableIdValues,
  1377.             ISQLFieldConverter sqlConverter,
  1378.             IJDBCServiceSearchWithoutId<?, ?> serviceWithoutId,
  1379.             IExpression condition, UpdateField ... updateFields) throws ServiceException, NotImplementedException, Exception{
  1380.         updateFields(jdbcProperties, log, connection, sqlQueryObject, rootTable, mapTableToPKColumn, rootTableIdValues, sqlConverter, 
  1381.                 null, null, serviceWithoutId, condition, updateFields);
  1382.     }
  1383.     private static void updateFields(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  1384.             String rootTable, Map<String, List<IField>> mapTableToPKColumn, List<Object> rootTableIdValues,
  1385.             ISQLFieldConverter sqlConverter,
  1386.             IJDBCServiceSearchSingleObject<?, ?> serviceSingleObject,
  1387.             IJDBCServiceSearchWithId<?, ?, ?> serviceWithId,
  1388.             IJDBCServiceSearchWithoutId<?, ?> serviceWithoutId,
  1389.             IExpression condition, UpdateField ... updateFields) throws ServiceException, NotImplementedException, Exception{
  1390.         
  1391.         if(updateFields==null || updateFields.length<=0){
  1392.             throw new ServiceException("Parameter updateFields is not defined");
  1393.         }
  1394.         
  1395.         // *** Suddivisione per tabella ***
  1396.         
  1397.         Map<String, List<UpdateField>> updateMap = new HashMap<String, List<UpdateField>>();
  1398.         for (int i = 0; i < updateFields.length; i++) {
  1399.             String tableName = sqlConverter.toTable(updateFields[i].getField());
  1400.             if(tableName==null){
  1401.                 throw new ServiceException("Field ["+updateFields[i].getField().getFieldName()+" of "+updateFields[i].getField().getClassName()+"] is not defined in sql converter");
  1402.             }
  1403.             List<UpdateField> list = updateMap.remove(tableName);
  1404.             if(list==null){
  1405.                 list = new ArrayList<UpdateField>();
  1406.             }
  1407.             list.add(updateFields[i]);
  1408.             updateMap.put(tableName, list);
  1409.         }
  1410.         
  1411.         for (String table : updateMap.keySet()) {
  1412.             
  1413.             _engineUpdateFields(jdbcProperties, log, connection, sqlQueryObject, sqlConverter, serviceSingleObject, 
  1414.                     serviceWithId, serviceWithoutId, rootTable, mapTableToPKColumn, rootTableIdValues, table, condition, updateMap.get(table));
  1415.         }
  1416.     }
  1417.                 
  1418.     private static void _engineUpdateFields(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  1419.             ISQLFieldConverter sqlConverter,
  1420.             IJDBCServiceSearchSingleObject<?, ?> serviceSingleObject,
  1421.             IJDBCServiceSearchWithId<?, ?, ?> serviceWithId,
  1422.             IJDBCServiceSearchWithoutId<?, ?> serviceWithoutId,
  1423.             String rootTable, Map<String, List<IField>> mapTableToPKColumn, List<Object> rootTableIdValues,
  1424.             String table, IExpression condition, List<UpdateField> updateFields) throws ServiceException, NotImplementedException, Exception{       
  1425.             
  1426.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  1427.                 new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);
  1428.         
  1429.         // Una tabella può non avere una PK
  1430. //      if(mapTableToPKColumn.containsKey(table)==false){
  1431. //          throw new ServiceException("PrimaryKey columns not defined for table ["+table+"]");
  1432. //      }
  1433.         
  1434.         
  1435.         // *** Update per tabella ***
  1436.                     
  1437.         ISQLQueryObject sqlQueryObjectUpdate = sqlQueryObject.newSQLQueryObject();
  1438.         sqlQueryObjectUpdate.setANDLogicOperator(true);
  1439.         sqlQueryObjectUpdate.addUpdateTable(table);
  1440.         
  1441.         // update fields
  1442.         java.util.List<JDBCObject> lstObjectsUpdate = new java.util.ArrayList<>();
  1443.         for (UpdateField updateField : updateFields) {
  1444.             sqlQueryObjectUpdate.addUpdateField(sqlConverter.toColumn(updateField.getField(),false), "?");
  1445.             lstObjectsUpdate.add(new JDBCObject(updateField.getValue(), updateField.getField().getFieldType()));
  1446.         }
  1447.         
  1448.         boolean update = true;
  1449.         
  1450.         // rootTable pk fields
  1451.         JDBCPaginatedExpression rootTablePKExpresion = new JDBCPaginatedExpression(sqlConverter);
  1452.         rootTablePKExpresion.and();
  1453.         List<IField> rootTableListPKColumns = mapTableToPKColumn.get(rootTable);
  1454.         if(rootTableListPKColumns!=null && rootTableIdValues!=null){
  1455.             if(rootTableListPKColumns.size()!=rootTableIdValues.size()){
  1456.                 throw new ServiceException("Number of primary key column ("+rootTableListPKColumns.size()+") and numbero of column values ("+
  1457.                         rootTableIdValues.size()+") isn't equals");
  1458.             }
  1459.             for (int i = 0; i < rootTableListPKColumns.size(); i++) {
  1460.                 rootTablePKExpresion.equals(rootTableListPKColumns.get(i), rootTableIdValues.get(i));
  1461.             }
  1462.         }
  1463.         // where condition custom
  1464.         if(condition!=null){
  1465.             rootTablePKExpresion.and(condition);
  1466.         }
  1467.         // for generate join condition
  1468.         rootTablePKExpresion.sortOrder(SortOrder.ASC).addOrder(updateFields.get(0).getField()); 
  1469.         
  1470.         // column ids
  1471.         if(rootTable.equals(table) && condition==null){
  1472.             
  1473.             // Se sto aggiornando la root table, e non vi sono condizioni dinamiche (le quali possono riferire anche tabelle interne)
  1474.             // non serve effettuare una ulteriore query che identifica gli id, ma posso applicare direttamente il where delle root columns.
  1475.             if(rootTableListPKColumns!=null && rootTableIdValues!=null){
  1476.                 StringBuilder bfRowIdentification = new StringBuilder();
  1477.                 bfRowIdentification.append("( ");
  1478.                 for (int i = 0; i < rootTableListPKColumns.size(); i++) {
  1479.                     if(i>0){
  1480.                         bfRowIdentification.append(" AND ");
  1481.                     }
  1482.                     IField columnId = rootTableListPKColumns.get(i);
  1483.                     bfRowIdentification.append(sqlConverter.toColumn(columnId, true)).append("=?");
  1484.                     lstObjectsUpdate.add(new JDBCObject(rootTableIdValues.get(i), columnId.getFieldType()));
  1485.                 }
  1486.                 bfRowIdentification.append(" )");
  1487.                 sqlQueryObjectUpdate.addWhereCondition(bfRowIdentification.toString());
  1488.             }
  1489.         }
  1490.         else{
  1491.             ISQLQueryObject sqlQueryObjectSelect = sqlQueryObjectUpdate.newSQLQueryObject();
  1492.             sqlQueryObjectSelect.setANDLogicOperator(true);
  1493.             try{
  1494.                 List<IField> columnIds = mapTableToPKColumn.get(table);
  1495.                 if(columnIds!=null && columnIds.size()>0){
  1496.                     List<Map<String, Object>> valueIds = null;
  1497.                     if(serviceSingleObject!=null){
  1498.                         valueIds = serviceSingleObject.select(jdbcProperties, log, connection, sqlQueryObjectSelect, rootTablePKExpresion, 
  1499.                                 true, columnIds.toArray(new IField[]{}));
  1500.                     }
  1501.                     else if(serviceWithoutId!=null){
  1502.                         valueIds = serviceWithoutId.select(jdbcProperties, log, connection, sqlQueryObjectSelect, rootTablePKExpresion, 
  1503.                                 true, columnIds.toArray(new IField[]{}));
  1504.                     }
  1505.                     else if(serviceWithId!=null){
  1506.                         valueIds = serviceWithId.select(jdbcProperties, log, connection, sqlQueryObjectSelect, rootTablePKExpresion, 
  1507.                                 true, columnIds.toArray(new IField[]{}));
  1508.                     }
  1509.                     if(valueIds!=null) {
  1510.                         // Questo controllo e' sbagliato. Devo poter aggiornare dei singoli campi su piu' righe di oggetti interni. 
  1511.                         // Se voglio identificare esattamente una sola riga di un oggetto interno devo usare la condition
  1512.                         // Mentre l'oggetto "daoInterface" lo identifico esattamente (o grazie all'id, o grazie all'oggetto stesso e quindi l'id long, o grazie alla singola istanza) 
  1513.         //              if(valueIds.size()>1){
  1514.         //                  throw new ServiceException("Cannot exists more columns with PK column ids (table:"+table+"), found: "+valueIds.size());
  1515.         //              }
  1516.                         StringBuilder bfRowIdentification = new StringBuilder();
  1517.                         bfRowIdentification.append("( ");
  1518.                         for (int i = 0; i < valueIds.size(); i++) {
  1519.                             if(i>0){
  1520.                                 bfRowIdentification.append(" OR ");
  1521.                             }
  1522.                             Map<String, Object> mapColumnValue = valueIds.get(i);
  1523.                             bfRowIdentification.append("( ");
  1524.                             for (int j = 0; j < columnIds.size(); j++) {
  1525.                                 if(j>0){
  1526.                                     bfRowIdentification.append(" AND ");
  1527.                                 }
  1528.                                 IField columnId = columnIds.get(j);
  1529.                                 bfRowIdentification.append(sqlConverter.toColumn(columnId, true)).append("=?");
  1530.                                 lstObjectsUpdate.add(new JDBCObject(mapColumnValue.get(columnId.getFieldName()), columnId.getFieldType()));
  1531.                             }   
  1532.                             bfRowIdentification.append(" )");
  1533.                         }
  1534.                         bfRowIdentification.append(" )");
  1535.                         sqlQueryObjectUpdate.addWhereCondition(bfRowIdentification.toString());
  1536.                     }
  1537.                 }
  1538.             }catch(NotFoundException notFound){
  1539.                 update = false;
  1540.                 log.debug("UpdateField["+table+"]: NotFound");
  1541.             }
  1542.         }
  1543.             
  1544.         if(update){
  1545.             int updateRow = jdbcUtilities.executeUpdate(sqlQueryObjectUpdate.createSQLUpdate(), jdbcProperties.isShowSql(), 
  1546.                     lstObjectsUpdate.toArray(new JDBCObject[]{}));
  1547.             log.debug("UpdateField["+table+"]: "+updateRow +" rows");
  1548.         }
  1549.                 
  1550.     }
  1551.     

  1553.     
  1554.     /* *** NATIVE ** */
  1555.     
  1556.     public static List<List<Object>> nativeQuery(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  1557.             String sql,List<Class<?>> returnClassTypes,Object ... param) throws SQLQueryObjectException, JDBCAdapterException, ServiceException{
  1558.         
  1559.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  1560.                 new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);
  1561.                 
  1562.         java.util.List<org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject> listParams = 
  1563.             new java.util.ArrayList<org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject>();
  1564.         for (Object jdbcObject : param) {
  1565.             org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject jdbc =
  1566.                 new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject(jdbcObject,jdbcObject.getClass());
  1567.             listParams.add(jdbc);
  1568.         }
  1569.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject [] paramArray = null;
  1570.         if(listParams.size()>0){
  1571.             paramArray = listParams.toArray(new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject [1]);
  1572.         }
  1573.         
  1574.         return jdbcUtilities.executeQuery(sql, jdbcProperties.isShowSql(), returnClassTypes ,paramArray);
  1575.     }
  1576.     
  1577.     public static int nativeUpdate(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  1578.             String sql,Object ... param) throws SQLQueryObjectException, JDBCAdapterException, ServiceException{
  1579.         
  1580.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  1581.                 new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);
  1582.                 
  1583.         java.util.List<org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject> listParams = 
  1584.             new java.util.ArrayList<org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject>();
  1585.         for (Object jdbcObject : param) {
  1586.             org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject jdbc =
  1587.                 new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject(jdbcObject,jdbcObject.getClass());
  1588.             listParams.add(jdbc);
  1589.         }
  1590.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject [] paramArray = null;
  1591.         if(listParams.size()>0){
  1592.             paramArray = listParams.toArray(new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject [1]);
  1593.         }
  1594.         
  1595.         return jdbcUtilities.executeUpdate(sql, jdbcProperties.isShowSql(), paramArray);
  1596.     }
  1597.     
  1598. }
Created with JaCoCo 0.8.8.202204050719