ExpressionSQL.java

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

  21. package org.openspcoop2.generic_project.expression.impl.sql;

  23. import java.sql.Timestamp;
  24. import java.util.ArrayList;
  25. import java.util.Arrays;
  26. import java.util.Iterator;
  27. import java.util.List;
  28. import java.util.Map;

  30. import org.openspcoop2.generic_project.beans.AliasField;
  31. import org.openspcoop2.generic_project.beans.ComplexField;
  32. import org.openspcoop2.generic_project.beans.ConstantField;
  33. import org.openspcoop2.generic_project.beans.CustomField;
  34. import org.openspcoop2.generic_project.beans.Field;
  35. import org.openspcoop2.generic_project.beans.Function;
  36. import org.openspcoop2.generic_project.beans.FunctionField;
  37. import org.openspcoop2.generic_project.beans.IAliasTableField;
  38. import org.openspcoop2.generic_project.beans.IField;
  39. import org.openspcoop2.generic_project.beans.IModel;
  40. import org.openspcoop2.generic_project.beans.UnixTimestampIntervalField;
  41. import org.openspcoop2.generic_project.exception.ExpressionException;
  42. import org.openspcoop2.generic_project.exception.ExpressionNotImplementedException;
  43. import org.openspcoop2.generic_project.expression.Index;
  44. import org.openspcoop2.generic_project.expression.LikeMode;
  45. import org.openspcoop2.generic_project.expression.SortOrder;
  46. import org.openspcoop2.generic_project.expression.impl.BetweenExpressionImpl;
  47. import org.openspcoop2.generic_project.expression.impl.Comparator;
  48. import org.openspcoop2.generic_project.expression.impl.ComparatorExpressionImpl;
  49. import org.openspcoop2.generic_project.expression.impl.ConjunctionExpressionImpl;
  50. import org.openspcoop2.generic_project.expression.impl.DateTimePartExpressionImpl;
  51. import org.openspcoop2.generic_project.expression.impl.DayFormatExpressionImpl;
  52. import org.openspcoop2.generic_project.expression.impl.ExpressionImpl;
  53. import org.openspcoop2.generic_project.expression.impl.InExpressionImpl;
  54. import org.openspcoop2.generic_project.expression.impl.LikeExpressionImpl;
  55. import org.openspcoop2.generic_project.expression.impl.OrderedField;
  56. import org.openspcoop2.generic_project.expression.impl.formatter.IObjectFormatter;
  57. import org.openspcoop2.utils.TipiDatabase;
  58. import org.openspcoop2.utils.sql.DateTimePartEnum;
  59. import org.openspcoop2.utils.sql.DayFormatEnum;
  60. import org.openspcoop2.utils.sql.ISQLQueryObject;
  61. import org.openspcoop2.utils.sql.SQLQueryObjectAlreadyExistsException;
  62. import org.openspcoop2.utils.sql.SQLQueryObjectCore;
  63. import org.openspcoop2.utils.sql.SQLQueryObjectException;

  65. /**
  66.  * ExpressionSQL
  67.  * 
  68.  * @author Poli Andrea (apoli@link.it)
  69.  * @author $Author$
  70.  * @version $Rev$, $Date$
  71.  */
  72. public class ExpressionSQL extends ExpressionImpl {

  74.     private static final String EXPRESSION_NOT_INITIALIZED = "Expression is not initialized";
  75.     private static final String EXPRESSION_TYPE_PREFIX = "ExpressioneEngine (type:";
  76.     private static final String IS_NOT_AS_CAST_WITH = ") is not as cast with ";
  77.     private static final String FIELD_TYPE_UNKNOWN_PREFIX = "Field type unknown [";
  78.     
  79.     private boolean throwExpressionNotInitialized = false;
  80.     
  81.     private TipiDatabase databaseType;
  82.     public TipiDatabase getDatabaseType() {
  83.         return this.databaseType;
  84.     }

  86.     private ISQLFieldConverter sqlFieldConverter;
  87.     public ISQLFieldConverter getSqlFieldConverter() {
  88.         return this.sqlFieldConverter;
  89.     }
  90.     public void setSqlFieldConverter(ISQLFieldConverter sqlFieldConverter) {
  91.         this.sqlFieldConverter = sqlFieldConverter;
  92.     }
  93.     
  94.     private boolean usedForCountExpression = false;
  95.     public boolean isUsedForCountExpression() {
  96.         return this.usedForCountExpression;
  97.     }
  98.     public void setUsedForCountExpression(boolean usedForCountExpression) {
  99.         this.usedForCountExpression = usedForCountExpression;
  100.     }
  101.     
  102.     public ExpressionSQL(ISQLFieldConverter sqlFieldConverter) throws ExpressionException {
  103.         super();
  104.         this.sqlFieldConverter = sqlFieldConverter;
  105.         if(this.sqlFieldConverter!=null){
  106.             this.databaseType = this.sqlFieldConverter.getDatabaseType();
  107.         }
  108.     }
  109.     public ExpressionSQL(ISQLFieldConverter sqlFieldConverter,IObjectFormatter objectFormatter) throws ExpressionException{
  110.         super(objectFormatter);
  111.         this.sqlFieldConverter = sqlFieldConverter;
  112.         if(this.sqlFieldConverter!=null){
  113.             this.databaseType = this.sqlFieldConverter.getDatabaseType();
  114.         }
  115.     }
  116.     public ExpressionSQL(PaginatedExpressionSQL expression) throws ExpressionException{
  117.         super(expression);
  118.         this.sqlFieldConverter = expression.getSqlFieldConverter();
  119.         this.fieldsManuallyAdd = expression.getFieldsManuallyAdd();
  120.         /**this.checkFieldManuallyAdd = expression.checkFieldManuallyAdd;*/
  121.         if(this.sqlFieldConverter!=null){
  122.             this.databaseType = this.sqlFieldConverter.getDatabaseType();
  123.         }
  124.     }

  126.     private List<Object> fieldsManuallyAdd = new ArrayList<>();
  127.     public List<Object> getFieldsManuallyAdd() {
  128.         return this.fieldsManuallyAdd;
  129.     }
  130.     public void removeFieldManuallyAdd(Object o) {
  131.         if(this.fieldsManuallyAdd.contains(o)){
  132.             this.fieldsManuallyAdd.remove(o);
  133.         }
  134.     }
  135.     
  136.     private boolean checkFieldManuallyAdd = true;
  137.     public void setCheckFieldManuallyAdd(boolean checkFieldManuallyAdd) {
  138.         this.checkFieldManuallyAdd = checkFieldManuallyAdd;
  139.     }
  140.     @Override
  141.     public boolean inUseField(IField field,boolean checkOnlyWhereCondition) throws ExpressionNotImplementedException, ExpressionException {
  142.         return ExpressionSQL.inUse(field, checkOnlyWhereCondition, super.inUseField(field,checkOnlyWhereCondition), this.getFieldsManuallyAdd(),this.checkFieldManuallyAdd);
  143.     }
  144.     @Override
  145.     public boolean inUseModel(IModel<?> model,boolean checkOnlyWhereCondition) throws ExpressionNotImplementedException, ExpressionException {
  146.         return ExpressionSQL.inUse(model, checkOnlyWhereCondition, super.inUseModel(model,checkOnlyWhereCondition), this.getFieldsManuallyAdd(),this.checkFieldManuallyAdd);
  147.     }
  148.     @Override
  149.     public List<IField> getFields(boolean onlyWhereCondition) throws ExpressionNotImplementedException, ExpressionException{
  150.         return ExpressionSQL.getFields(onlyWhereCondition, super.getFields(onlyWhereCondition), this.getFieldsManuallyAdd(),this.checkFieldManuallyAdd);
  151.     }
  152.     
  153.     
  154.     /* ************ COMPARATOR *********** */
  155.     
  156.     public static Comparator getCorrectComparator(Comparator comparator,TipiDatabase databaseType){
  157.         if(databaseType!=null && TipiDatabase.ORACLE.equals(databaseType)){
  158.             if(Comparator.IS_EMPTY.equals(comparator)){
  159.                 return Comparator.IS_NULL; // le stringhe vuote in oracle vengono inserite come null
  160.             }
  161.             else if(Comparator.IS_NOT_EMPTY.equals(comparator)){
  162.                 return Comparator.IS_NOT_NULL; // le stringhe vuote in oracle vengono inserite come null, inoltre la ricerca <> '' non funziona
  163.             }
  164.         }
  165.         return comparator;
  166.     }
  167.     
  168.     @Override
  169.     protected Comparator getCorrectComparator(Comparator comparator){
  170.         return ExpressionSQL.getCorrectComparator(comparator, this.databaseType);
  171.     }
  172.     
  173.     /* ************ TO SQL ENGINE *********** */
  174.     
  175.     
  176.     // SQL FORCE INDEX

  178.     private String toSqlForceIndex()throws ExpressionException{
  179.         
  180.         return ExpressionSQL.sqlForceIndex(this.sqlFieldConverter, this.getForceIndexes());

  182.     }
  183.     
  184.     protected static String sqlForceIndex(ISQLFieldConverter fieldConverter,List<Index> forceIndexes) throws ExpressionException{
  185.         try{
  186.             
  187.             StringBuilder bf = new StringBuilder();
  188.             
  189.             if(!forceIndexes.isEmpty()){
  190.                 for (Iterator<Index> iterator =forceIndexes.iterator(); iterator.hasNext();) {
  191.                     Index forceIndex = iterator.next();
  192.                     String forceIndexSql = "/*+ index("+fieldConverter.toTable(forceIndex.getModel(),false)+" "+forceIndex.getName()+") */";
  193.                     bf.append(" ");
  194.                     bf.append(forceIndexSql);
  195.                 }
  196.             }
  197.                 
  198.             return bf.toString();
  199.             
  200.         }catch(Exception e){
  201.             throw new ExpressionException(e);
  202.         }
  203.     }
  204.     
  205.     private void toSqlForceIndex(ISQLQueryObject sqlQueryObject)throws ExpressionException{
  206.     
  207.         ExpressionSQL.sqlForceIndex(this.sqlFieldConverter, sqlQueryObject,this.getForceIndexes());
  208.         
  209.     }
  210.     
  211.     protected static void sqlForceIndex(ISQLFieldConverter fieldConverter, ISQLQueryObject sqlQueryObject,List<Index> forceIndexes) throws ExpressionException{
  212.         try{
  213.             
  214.             if(!forceIndexes.isEmpty()){
  215.                 for (Iterator<Index> iterator =forceIndexes.iterator(); iterator.hasNext();) {
  216.                     Index forceIndex = iterator.next();
  217.                     sqlQueryObject.addSelectForceIndex(fieldConverter.toTable(forceIndex.getModel(),false), forceIndex.getName());
  218.                 }
  219.             }
  220.             
  221.         }catch(Exception e){
  222.             throw new ExpressionException(e);
  223.         }
  224.     }
  225.     
  226.     
  227.     
  228.     
  229.     
  230.     // SQL ORDER

  232.     private String toSqlOrder()throws ExpressionException{
  233.         
  234.         return ExpressionSQL.sqlOrder(this.sqlFieldConverter, this.getSortOrder(), this.getOrderedFields());

  236.     }
  237.     
  238.     protected static String sqlOrder(ISQLFieldConverter fieldConverter,SortOrder sortOrder,List<OrderedField> orderedFields) throws ExpressionException{
  239.         try{
  240.             
  241.             StringBuilder bf = new StringBuilder();
  242.             if(!SortOrder.UNSORTED.equals(sortOrder)){
  243.                     
  244.                 bf.append(" ORDER BY ");
  245.                 if(!orderedFields.isEmpty()){
  246.                     int index = 0;
  247.                     for (Iterator<OrderedField> iterator =orderedFields.iterator(); iterator.hasNext();) {
  248.                         OrderedField orderedField = iterator.next();
  249.                         IField field = orderedField.getField();
  250.                         if(index>0){
  251.                             bf.append(" , ");
  252.                         }
  253.                         bf.append(fieldConverter.toColumn(field,true));
  254.                         bf.append(" ");
  255.                         bf.append(orderedField.getSortOrder().name());
  256.                         index++;
  257.                     }
  258.                 }else{
  259.                     bf.append(" id");
  260.                     bf.append(" ");
  261.                     bf.append(sortOrder.name());
  262.                 }
  263.             }
  264.                 
  265.             return bf.toString();
  266.             
  267.         }catch(Exception e){
  268.             throw new ExpressionException(e);
  269.         }
  270.     }
  271.     
  272.     private void toSqlOrder(ISQLQueryObject sqlQueryObject)throws ExpressionException{
  273.     
  274.         ExpressionSQL.sqlOrder(this.sqlFieldConverter, sqlQueryObject,this.getSortOrder(), this.getOrderedFields(), this.getGroupByFields());
  275.         
  276.     }
  277.     
  278.     protected static void sqlOrder(ISQLFieldConverter fieldConverter, ISQLQueryObject sqlQueryObject,SortOrder sortOrder,List<OrderedField> orderedFields,
  279.             List<IField> groupByFields) throws ExpressionException{
  280.         try{
  281.             
  282.             if(!SortOrder.UNSORTED.equals(sortOrder)){
  283.                 
  284.                 if(!orderedFields.isEmpty()){
  285.                     for (Iterator<OrderedField> iterator = orderedFields.iterator(); iterator.hasNext();) {
  286.                         OrderedField orderedField = iterator.next();
  287.                         IField field = orderedField.getField();
  288.                         
  289.                         String columnOrderAlias = fieldConverter.toColumn(field,true,true);
  290.                         String columnOrderBy = fieldConverter.toColumn(field,true);
  291.                         sqlQueryObject.addOrderBy(columnOrderBy,SortOrder.ASC.equals(orderedField.getSortOrder()));
  292.                         
  293.                         // Search by alias
  294.                         List<String> v = new ArrayList<>();
  295.                         try{
  296.                             v = sqlQueryObject.getFieldsName();
  297.                         }catch(Exception e){v = new ArrayList<>();}
  298.                         boolean contains = false;
  299.                         /**System.out.println("SEARCH ALIAS ["+columnOrderAlias+"] ...");*/
  300.                         if(v.contains(columnOrderAlias)){
  301.                             contains = true;
  302.                             /**System.out.println("SEARCH ALIAS ["+columnOrderAlias+"] FOUND");*/
  303.                         }
  304.                         
  305.                         
  306.                         // Search by column name
  307.                         if(!contains){
  308.                             try{
  309.                                 v = ((SQLQueryObjectCore)sqlQueryObject).getFields();
  310.                             }catch(Exception e){}
  311.                             /**System.out.println("SEARCH COLUMN ["+columnOrderBy+"] ...");*/
  312.                             if(v.contains(columnOrderBy)){
  313.                                 contains = true;
  314.                                 /**System.out.println("SEARCH COLUMN ["+columnOrderBy+"] FOUND");*/
  315.                             }
  316.                         }
  317.                         
  318.                         // Search by column name (split alias)
  319.                         if(!contains){
  320.                             /**System.out.println("SEARCH COLUMN SPLIT ["+columnOrderBy+"] ...");*/
  321.                             for (int i = 0; i < v.size(); i++) {
  322.                                 String column = v.get(0);
  323.                                 /**System.out.println("SEARCH COLUMN SPLITi ["+columnOrderBy+"] ["+i+"]: "+column);*/
  324.                                 if(column.contains(" as ")){
  325.                                     String [] tmp = column.split(" as ");
  326.                                     /**System.out.println("SEARCH COLUMN SPLIT A ["+columnOrderBy+"] ["+i+"]: "+column+"   AS ["+tmp[0]+"]");*/
  327.                                     if(tmp[0].equals(columnOrderBy)){
  328.                                         contains = true;
  329.                                         /**System.out.println("FOUND COLUMN SPLIT A!!!");*/
  330.                                         break;
  331.                                     }
  332.                                 }
  333.                                 else if(column.contains(" ")){
  334.                                     String [] tmp = column.split(" ");
  335.                                     /**System.out.println("SEARCH COLUMN SPLIT ["+columnOrderBy+"] ["+i+"]: "+column+"   AS2 ["+tmp[0]+"]");*/
  336.                                     if(tmp[0].equals(columnOrderBy)){
  337.                                         contains = true;
  338.                                         /**System.out.println("FOUND COLUMN SPLIT B!!!");*/
  339.                                         break;
  340.                                     }
  341.                                 }
  342.                             }
  343.                         }
  344.                         
  345.                         /**System.out.println("FIX ORACLE ["+columnOrderBy+"]: "+!contains);*/
  346.                         // Fix per oracle
  347.                         if(!contains){
  348.                             // Devo aggiungerlo solo se la colonna non fa gia' parte del group by condition, altrimenti tale colonna finira' comunque tra i select field.
  349.                             boolean add = true;
  350.                             if(groupByFields!=null){
  351.                                 for (IField groupByField : groupByFields) {
  352.                                     if(groupByField.equals(field)){
  353.                                         add = false;
  354.                                         break;
  355.                                     }
  356.                                 }
  357.                             }
  358.                             if(add){
  359.                                 /**System.out.println("ADD SELECT FIELD ["+field.getClass().getName()+"] ["+columnOrderBy+"]");*/
  360.                                 if(field instanceof UnixTimestampIntervalField){
  361.                                     UnixTimestampIntervalField unix = (UnixTimestampIntervalField) field;
  362.                                     String alias = null;
  363.                                     if(unix.existsAlias()==false){
  364.                                         /**System.out.println("NOT EXISTS");*/
  365.                                         unix.buildAlias();
  366.                                     }
  367.                                     alias = unix.getAlias();
  368.                                     /**System.out.println("ALIAS ["+alias+"]");*/
  369.                                     sqlQueryObject.addSelectAliasField(columnOrderBy, alias);
  370.                                 }
  371.                                 else{
  372.                                     sqlQueryObject.addSelectField(columnOrderBy);
  373.                                 }
  374.                             }
  375.                         }
  376.                     }
  377.                 }else{
  378.                     sqlQueryObject.addOrderBy("id");
  379.                 }
  380.                 if(SortOrder.ASC.equals(sortOrder)){
  381.                     sqlQueryObject.setSortType(true);
  382.                 }else{
  383.                     sqlQueryObject.setSortType(false);
  384.                 }
  385.             }
  386.             
  387.         }catch(Exception e){
  388.             throw new ExpressionException(e);
  389.         }
  390.     }
  391.     
  392.     
  393.     
  394.     
  395.     // SQL GROUP BY
  396.     
  397.     private String toSqlGroupBy()throws ExpressionException{
  398.         
  399.         return ExpressionSQL.sqlGroupBy(this.sqlFieldConverter, this.groupByFields);

  401.     }
  402.     
  403.     protected static String sqlGroupBy(ISQLFieldConverter fieldConverter,List<IField> groupByFields) throws ExpressionException{
  404.         try{
  405.             
  406.             StringBuilder bf = new StringBuilder();
  407.                     
  408.             if(!groupByFields.isEmpty()){
  409.                 bf.append(" GROUP BY ");
  410.                 int index = 0;
  411.                 for (Iterator<IField> iterator =groupByFields.iterator(); iterator.hasNext();) {
  412.                     IField field = iterator.next();
  413.                     if(index>0){
  414.                         bf.append(" , ");
  415.                     }
  416.                     bf.append(fieldConverter.toColumn(field,true));
  417.                     index++;
  418.                 }
  419.             }
  420.                 
  421.             return bf.toString();
  422.             
  423.         }catch(Exception e){
  424.             throw new ExpressionException(e);
  425.         }
  426.     }
  427.     
  428.     private void toSqlGroupBy(ISQLQueryObject sqlQueryObject)throws ExpressionException{
  429.         
  430.         ExpressionSQL.sqlGroupBy(this.sqlFieldConverter, sqlQueryObject, this.groupByFields);
  431.         
  432.     }
  433.     
  434.     protected static void sqlGroupBy(ISQLFieldConverter fieldConverter, ISQLQueryObject sqlQueryObject,List<IField> groupByFields) throws ExpressionException{
  435.         try{
  436.             
  437.             if(!groupByFields.isEmpty()){
  438.                 for (Iterator<IField> iterator = groupByFields.iterator(); iterator.hasNext();) {
  439.                     IField field = iterator.next();
  440.                     sqlQueryObject.addGroupBy(fieldConverter.toColumn(field,true));
  441.                 }
  442.             }
  443.             
  444.         }catch(Exception e){
  445.             throw new ExpressionException(e);
  446.         }
  447.     }
  448.     
  449.     private void toSqlGroupBySelectField(ISQLQueryObject sqlQueryObject)throws ExpressionException{
  450.         
  451.         ExpressionSQL.sqlGroupBySelectField(this.sqlFieldConverter, sqlQueryObject, this.fieldsManuallyAdd, 
  452.                 this.groupByFields, this.usedForCountExpression);
  453.         
  454.     }
  455.     
  456.     protected static void sqlGroupBySelectField(ISQLFieldConverter fieldConverter,  ISQLQueryObject sqlQueryObject, 
  457.             List<Object> selectFieldsManuallyAdd, List<IField> groupByFields, boolean usedForCountExpression) throws ExpressionException{
  458.         if(!usedForCountExpression){
  459.             try{
  460.                 if(groupByFields!=null){
  461.                     for (IField iField : groupByFields) {
  462.                         
  463.                         /**System.out.println("CHECK ["+iField.getFieldName()+"] ["+iField.getFieldType().getName()+"] ...");*/
  464.                         
  465.                         // check tra altri select field add manually
  466.                         boolean found = false;
  467.                         for (Object checkSelectFieldManuallyAdd : selectFieldsManuallyAdd) {
  468.                             if(checkSelectFieldManuallyAdd instanceof IField &&
  469.                                 (iField.equals((checkSelectFieldManuallyAdd)))
  470.                                 ){
  471.                                 found=true;
  472.                                 break;
  473.                             }
  474.                         }
  475.                         /**System.out.println("CHECK ["+iField.getFieldName()+"] ["+iField.getFieldType().getName()+"] found in selectFieldsManuallyAdd: "+found);*/
  476.                         if(found)
  477.                             continue;
  478.                         
  479.                         // check in sql Query Object
  480.                         String column1 = fieldConverter.toColumn(iField, true);
  481.                         String column2 = fieldConverter.toColumn(iField, false);
  482.                         /**System.out.println("CHECK ["+iField.getFieldName()+"] ["+iField.getFieldType().getName()+"] COLUMN1["+column1+"] COLUMN2["+column2+"]");*/
  483.                         boolean insert = true;
  484.                         try{
  485.                             insert = !sqlQueryObject.getFieldsName().contains(column1) && !sqlQueryObject.getFieldsName().contains(column2);
  486.                         }catch(org.openspcoop2.utils.sql.SQLQueryObjectException sql){}
  487.                         /**System.out.println("CHECK ["+iField.getFieldName()+"] ["+iField.getFieldType().getName()+"] INSERT["+insert+"]");*/
  488.                         if(insert){
  489.                             ExpressionSQL.addFieldEngine(sqlQueryObject, fieldConverter, iField, null, true);
  490.                             selectFieldsManuallyAdd.add(iField);
  491.                         }
  492.                         
  493.                     }
  494.                 }
  495.             }catch(Exception e){
  496.                 throw new ExpressionException(e.getMessage(),e);
  497.             }
  498.         }
  499.     }
  500.     
  501.     
  502.     
  503.     // SQL FROM
  504.     
  505.     protected static void sqlFrom(ISQLQueryObject sqlQueryObject,List<IField> fields,ISQLFieldConverter sqlFieldConverter,String tableNamePrincipale,
  506.             List<Object> fieldsManuallyAdd, List<OrderedField> orderByFields, List<IField> groupByFields) throws ExpressionException{
  507.         sqlFrom(sqlQueryObject, fields, sqlFieldConverter, tableNamePrincipale, fieldsManuallyAdd, orderByFields, groupByFields, true);
  508.     }
  509.     protected static void sqlFrom(ISQLQueryObject sqlQueryObject,List<IField> fields,ISQLFieldConverter sqlFieldConverter,String tableNamePrincipale,
  510.             List<Object> fieldsManuallyAdd, List<OrderedField> orderByFields, List<IField> groupByFields,
  511.             boolean ignoreAlreadyExistsException) throws ExpressionException{
  512.         try{
  513.             List<String> tables = new ArrayList<>();
  514.             
  515.             if(fields!=null){
  516.                 for (IField iField : fields) {
  517.                     String tableName = getTableName(iField,sqlFieldConverter);
  518.                     if(!tables.contains(tableName)){
  519.                         tables.add(tableName);
  520.                     }
  521.                 }
  522.             }
  523.             
  524.             if(fieldsManuallyAdd!=null){
  525.                 for (Object iField : fieldsManuallyAdd) {
  526.                     IField field = null;
  527.                     if(iField instanceof IField){
  528.                         field = (IField) iField;
  529.                         String tableName = getTableName(field,sqlFieldConverter);
  530.                         if(!tables.contains(tableName)){
  531.                             tables.add(tableName);
  532.                         }
  533.                     }
  534.                     else if(iField instanceof FunctionField){
  535.                         List<IField> fieldsFF = ((FunctionField) iField).getFields();
  536.                         for (IField iFieldFF : fieldsFF) {
  537.                             String tableName = getTableName(iFieldFF,sqlFieldConverter);
  538.                             if(!tables.contains(tableName)){
  539.                                 tables.add(tableName);
  540.                             }
  541.                         }
  542.                     }
  543.                     else{
  544.                         throw new ExpressionException(FIELD_TYPE_UNKNOWN_PREFIX+iField.getClass().getName()+"]");
  545.                     }
  546.                 }
  547.             }
  548.             
  549.             if(orderByFields!=null){
  550.                 for (OrderedField orderedField : orderByFields) {
  551.                     IField iField = orderedField.getField();
  552.                     String tableName = getTableName(iField,sqlFieldConverter);
  553.                     if(!tables.contains(tableName)){
  554.                         tables.add(tableName);
  555.                     }
  556.                 }
  557.             }
  558.             
  559.             if(groupByFields!=null){
  560.                 for (IField iField : groupByFields) {
  561.                     String tableName = getTableName(iField,sqlFieldConverter);
  562.                     if(!tables.contains(tableName)){
  563.                         tables.add(tableName);
  564.                     }
  565.                 }
  566.             }
  567.             
  568.             if(tableNamePrincipale!=null && !tables.contains(tableNamePrincipale)){
  569.                 tables.add(tableNamePrincipale);
  570.             }
  571.             
  572.             for (String tableName : tables) {
  573.                 if(tableName==null || "".equals(tableName)){
  574.                     // la tabella "" puo' essere usato come workaround per le funzioni es. unixTimestamp in CustomField
  575.                     continue;
  576.                 }
  577.                 try{
  578.                     if(tableName.contains(PREFIX_ALIAS_FIELD)){
  579.                         String originalTableName = tableName.split(PREFIX_ALIAS_FIELD)[0];
  580.                         String aliasTable = tableName.split(PREFIX_ALIAS_FIELD)[1];
  581.                         sqlQueryObject.addFromTable(originalTableName, aliasTable);
  582.                     }
  583.                     else{
  584.                         sqlQueryObject.addFromTable(tableName);
  585.                     }
  586.                 }
  587.                 catch(SQLQueryObjectAlreadyExistsException alreadyExists){
  588.                     if(!ignoreAlreadyExistsException){
  589.                         throw new ExpressionException(alreadyExists.getMessage(),alreadyExists);
  590.                     }
  591.                     else{
  592. /**                     System.out.println("ALREADY EXISTS: "+alreadyExists.getMessage());
  593. //                      alreadyExists.printStackTrace(System.out);*/
  594.                     }
  595.                 }
  596.             }
  597.         }catch(Exception e){
  598.             throw new ExpressionException(e.getMessage(),e);
  599.         }
  600.     }
  601.     private static final String PREFIX_ALIAS_FIELD = "_______ALIASFIELD_______";
  602.     private static String getTableName(IField iField,ISQLFieldConverter sqlFieldConverter) throws ExpressionException{
  603.         String tableName = null;
  604.         if(iField instanceof AliasField){
  605.             AliasField af = (AliasField) iField;
  606.             if(af.getAlias().contains(".")){
  607.                 String originaleTableName = sqlFieldConverter.toTable(iField);
  608.                 tableName = originaleTableName+PREFIX_ALIAS_FIELD+ af.getAlias().split("\\.")[0];
  609.             }else{
  610.                 tableName = sqlFieldConverter.toTable(iField);
  611.             }
  612.         }
  613.         else if(iField instanceof IAliasTableField){
  614.             IAliasTableField atf = (IAliasTableField) iField;
  615.             String originaleTableName = sqlFieldConverter.toTable(iField,false);
  616.             tableName = originaleTableName+PREFIX_ALIAS_FIELD+ atf.getAliasTable();
  617.         }
  618.         else{
  619.             tableName = sqlFieldConverter.toTable(iField);
  620.         }
  621.         /**System.out.println("ADD ["+tableName+"]");*/
  622.         return tableName;
  623.     }
  624.     
  625.     protected static void addFieldEngine(ISQLQueryObject sqlQueryObject, ISQLFieldConverter sqlFieldConverter, Object field, String aliasField, boolean appendTablePrefix)throws ExpressionException{
  626.         addFieldEngine(sqlQueryObject, sqlFieldConverter, field, aliasField, appendTablePrefix, true);
  627.     }
  628.     private static void addFieldEngine(ISQLQueryObject sqlQueryObject, ISQLFieldConverter sqlFieldConverter, Object field, String aliasField, boolean appendTablePrefix,
  629.             boolean ignoreAlreadyExistsException)throws ExpressionException{
  630.         try{        
  631.                     
  632.             if(field == null){
  633.                 throw new ExpressionException("Field is null");
  634.             }
  635.             /**System.out.println("ADD CLASS ["+field.getClass().getName()+"]...");*/
  636.             if(field instanceof FunctionField){
  637.                 
  638.                 FunctionField ff = (FunctionField) field;
  639.                 
  640.                 boolean customFunction = ff.isCustomFunction();
  641.                 String prefixCustomFunction = ff.getPrefixFunctionCustom();
  642.                 String suffixCustomFunction = ff.getSuffixFunctionCustom();
  643.                 Function function = ff.getFunction();
  644.                 
  645.                 String functionValue = ff.getFunctionValue();
  646.                 String operator = ff.getOperator();
  647.                 List<IField> fields = ff.getFields();
  648.                 String column = null;
  649.                 
  650.                 boolean timestamp = false;
  651.                 String ffFieldTypeName = ff.getFieldType().getName() + "";
  652.                 if(ffFieldTypeName.equals(Timestamp.class.getName()) ||
  653.                         ffFieldTypeName.equals(java.util.Date.class.getName()) ||
  654.                         ffFieldTypeName.equals(java.sql.Date.class.getName()) ||
  655.                         ffFieldTypeName.equals(java.util.Calendar.class.getName())){
  656.                     timestamp = true;
  657.                 }
  658.                 
  659.                 String alias = ff.getAlias();
  660.                 
  661.                 // calcolo colonna
  662.                 if(functionValue!=null){
  663.                     column = functionValue;
  664.                 }
  665.                 else{
  666.                     if(operator!=null){
  667.                         if(fields.size()>1 && timestamp){
  668.                             throw new ExpressionException("Multiple fields with operator and \"time\" type ("+ff.getFieldType().getName()+
  669.                                     ") not supported. For Timestamp Interval use FunctionField(new UnixTimestampIntervalField(...), Function.TIPE, columnName)");
  670.                         }
  671.                         StringBuilder bf = new StringBuilder();
  672.                         for (int i = 0; i < fields.size(); i++) {
  673.                             if(i>0){
  674.                                 bf.append(" ").append(operator).append(" ");
  675.                             }
  676.                             bf.append(sqlFieldConverter.toColumn(fields.get(i), appendTablePrefix));
  677.                         }
  678.                         column = bf.toString();
  679.                     }
  680.                     else{
  681.                         column = sqlFieldConverter.toColumn(fields.get(0), appendTablePrefix);
  682.                     }
  683.                 }
  684.                                                 
  685.                 if(customFunction){
  686.                     sqlQueryObject.addSelectAliasField(prefixCustomFunction+" "+column+" "+suffixCustomFunction, alias);
  687.                 }else{
  688.                     setFunction(function, timestamp, column, alias, sqlQueryObject);
  689.                 }
  690.             }
  691.             else if(field instanceof ConstantField){
  692.                 
  693.                 // Nelle costanti deve sempre essere usato l'alias.
  694.                 // Altrimenti nelle select annidate verrebbero dichiarate piu' volte le solite costanti.
  695.                 // Inoltre SQLServer pretende costanti con alias
  696.                 sqlQueryObject.addSelectAliasField(sqlFieldConverter.toColumn((ConstantField)field, appendTablePrefix), ((ConstantField)field).getAlias());
  697.                 
  698.             }
  699.             else if(field instanceof CustomField){
  700.                 
  701.                 if(aliasField!=null){
  702.                     sqlQueryObject.addSelectAliasField(sqlFieldConverter.toColumn((Field)field, appendTablePrefix), aliasField);
  703.                 }
  704.                 else{
  705.                     sqlQueryObject.addSelectField(sqlFieldConverter.toColumn((Field)field, appendTablePrefix));
  706.                 }
  707.             }
  708.             else if(field instanceof AliasField){
  709.                 
  710.                 AliasField af = (AliasField) field;
  711.                 IField afField = af.getField();
  712.                 sqlQueryObject.addSelectAliasField( sqlFieldConverter.toColumn(afField, appendTablePrefix) , af.getAlias() );
  713.                 /**System.out.println("ADD ALIAS ["+sqlFieldConverter.toColumn(afField, appendTablePrefix)+"]["+af.getAlias()+"]...");*/
  714.                 
  715.             }
  716.             else if(field instanceof Field){
  717.                 
  718.                 if(aliasField!=null){
  719.                     sqlQueryObject.addSelectAliasField(sqlFieldConverter.toColumn((Field)field, appendTablePrefix), aliasField);
  720.                 }
  721.                 else{
  722.                     sqlQueryObject.addSelectField(sqlFieldConverter.toColumn((Field)field, appendTablePrefix));
  723.                 }
  724.             }
  725.             else if(field instanceof ComplexField){
  726.                 if(aliasField!=null){
  727.                     sqlQueryObject.addSelectAliasField(sqlFieldConverter.toColumn((ComplexField)field, appendTablePrefix), aliasField);
  728.                     /**System.out.println("ADD ALIAS ["+sqlFieldConverter.toColumn((ComplexField)field, appendTablePrefix)+"]["+aliasField+"]...");*/
  729.                 }else{
  730.                     sqlQueryObject.addSelectField(sqlFieldConverter.toColumn((ComplexField)field, appendTablePrefix));
  731.                     /**System.out.println("ADD ["+sqlFieldConverter.toColumn((ComplexField)field, appendTablePrefix)+"]...");*/
  732.                 }
  733.             }
  734.             else{
  735.                 throw new ExpressionException("Field unknown type: "+field.getClass().getName());
  736.             }
  737.         
  738.         }
  739.         catch(SQLQueryObjectAlreadyExistsException e){
  740.             if(!ignoreAlreadyExistsException){
  741.                 throw new ExpressionException(e.getMessage(),e);
  742.             }
  743.             else{
  744. /**             System.out.println("ALREADY EXISTS: "+e.getMessage());
  745. //              e.printStackTrace(System.out);*/
  746.             }
  747.         }
  748.         catch(Exception e){
  749.             throw new ExpressionException(e.getMessage(),e);
  750.         }
  751.     }
  752.     
  753.     protected static void addAliasFieldEngine(ISQLQueryObject sqlQueryObject, ISQLFieldConverter sqlFieldConverter, Object field, String aliasField, boolean appendTablePrefix)throws ExpressionException{
  754.         addAliasFieldEngine(sqlQueryObject, sqlFieldConverter, field, aliasField, appendTablePrefix, true);
  755.     }
  756.     private static void addAliasFieldEngine(ISQLQueryObject sqlQueryObject, ISQLFieldConverter sqlFieldConverter, Object field, String aliasField, boolean appendTablePrefix,
  757.             boolean ignoreAlreadyExistsException)throws ExpressionException{
  758.         try{        
  759.                     
  760.             if(aliasField==null && appendTablePrefix) {
  761.                 // nop
  762.             }
  763.             
  764.             if(field == null){
  765.                 throw new ExpressionException("Field is null");
  766.             }
  767.             
  768.             if(field instanceof FunctionField){
  769.                 
  770.                 FunctionField ff = (FunctionField) field;
  771.                 String alias = ff.getAlias();
  772.                 sqlQueryObject.addSelectField(alias);
  773.                 
  774.             }
  775.             else if(field instanceof ConstantField){
  776.                 
  777.                 sqlQueryObject.addSelectField(((ConstantField)field).getAlias());
  778.                 
  779.             }
  780.             else if(field instanceof CustomField){
  781.                 
  782.                 sqlQueryObject.addSelectField(((CustomField)field).getAliasColumnName());
  783.                 
  784.             }
  785.             else if(field instanceof AliasField){
  786.                 
  787.                 AliasField af = (AliasField) field;
  788.                 sqlQueryObject.addSelectField(af.getAlias());
  789.                 
  790.             }
  791.             else if(field instanceof Field){
  792.                 
  793.                 sqlQueryObject.addSelectField(sqlFieldConverter.toAliasColumn(((Field)field), false));
  794.                 
  795.             }
  796.             else if(field instanceof ComplexField){
  797.                 
  798.                 sqlQueryObject.addSelectField(sqlFieldConverter.toAliasColumn(((ComplexField)field), false));
  799.                 
  800.             }
  801.             else{
  802.                 throw new ExpressionException("Field unknown type: "+field.getClass().getName());
  803.             }
  804.         
  805.         }
  806.         catch(SQLQueryObjectAlreadyExistsException e){
  807.             if(!ignoreAlreadyExistsException){
  808.                 throw new ExpressionException(e.getMessage(),e);
  809.             }
  810.             else{
  811. /**             System.out.println("ALREADY EXISTS: "+e.getMessage());
  812. //              e.printStackTrace(System.out);*/
  813.             }
  814.         }
  815.         catch(Exception e){
  816.             throw new ExpressionException(e.getMessage(),e);
  817.         }
  818.     }
  819.     
  820.     public static void setFunction(Function function,boolean timestamp,String column,String alias,ISQLQueryObject sqlQueryObject) throws SQLQueryObjectException{
  821.         switch (function) {
  822.         case AVG:
  823.         case AVG_DOUBLE:
  824.             if(timestamp){
  825.                 sqlQueryObject.addSelectAvgTimestampField(column, alias);
  826.             }
  827.             else{
  828.                 sqlQueryObject.addSelectAvgField(column, alias);
  829.             }
  830.             break;
  831.         case MAX:
  832.             if(timestamp){
  833.                 sqlQueryObject.addSelectMaxTimestampField(column, alias);
  834.             }
  835.             else{
  836.                 sqlQueryObject.addSelectMaxField(column, alias);
  837.             }
  838.             break;
  839.         case MIN:
  840.             if(timestamp){
  841.                 sqlQueryObject.addSelectMinTimestampField(column, alias);
  842.             }
  843.             else{
  844.                 sqlQueryObject.addSelectMinField(column, alias);
  845.             }
  846.             break;
  847.         case SUM:
  848.             if(timestamp){
  849.                 sqlQueryObject.addSelectSumTimestampField(column, alias);
  850.             }
  851.             else{
  852.                 sqlQueryObject.addSelectSumField(column, alias);
  853.             }
  854.             break;
  855.         case COUNT:
  856.             sqlQueryObject.addSelectCountField(column, alias, false);
  857.             break;
  858.         case COUNT_DISTINCT:
  859.             sqlQueryObject.addSelectCountField(column, alias, true);
  860.             break;
  861.         }
  862.     }
  863.     
  864.     protected static boolean inUse(IField fieldParam,boolean checkOnlyWhereCondition, 
  865.             boolean useFieldExpressionBase,List<Object> fieldsManuallyAdd,boolean checkFieldManuallyAdd) throws ExpressionException {
  866.         
  867.         if(!checkFieldManuallyAdd){
  868.             return useFieldExpressionBase;
  869.         }
  870.         if(checkOnlyWhereCondition){
  871.             return useFieldExpressionBase;
  872.         }
  873.         
  874.         for (Object iField : fieldsManuallyAdd) {
  875.             IField field = null;
  876.             if(iField instanceof IField){
  877.                 field = (IField) iField;
  878.                 boolean inUse = fieldParam.equals(field);
  879.                 if(inUse){
  880.                     return true;
  881.                 }
  882.             }
  883.             else if(iField instanceof FunctionField){
  884.                 List<IField> fieldsFF = ((FunctionField) iField).getFields();
  885.                 for (IField iFieldFF : fieldsFF) {
  886.                     boolean inUse = fieldParam.equals(iFieldFF);
  887.                     if(inUse){
  888.                         return true;
  889.                     }
  890.                 }
  891.             }
  892.             else{
  893.                 throw new ExpressionException(FIELD_TYPE_UNKNOWN_PREFIX+iField.getClass().getName()+"]");
  894.             }
  895.         }
  896.         
  897.         return useFieldExpressionBase;
  898.         
  899.     }
  900.     
  901.     protected static boolean inUse(IModel<?> model,boolean checkOnlyWhereCondition,
  902.             boolean useModelExpressionBase,List<Object> fieldsManuallyAdd,boolean checkFieldManuallyAdd) throws ExpressionException {
  903.         
  904.         if(!checkFieldManuallyAdd){
  905.             return useModelExpressionBase;
  906.         }
  907.         if(checkOnlyWhereCondition){
  908.             return useModelExpressionBase;
  909.         }
  910.         
  911.         for (Object iField : fieldsManuallyAdd) {
  912.             IField field = null;
  913.             if(iField instanceof IField){
  914.                 field = (IField) iField;
  915.                 if(inUseEngine(model, field)){
  916.                     return true;
  917.                 }
  918.             }
  919.             else if(iField instanceof FunctionField){
  920.                 List<IField> fieldsFF = ((FunctionField) iField).getFields();
  921.                 for (IField iFieldFF : fieldsFF) {
  922.                     if(inUseEngine(model, iFieldFF)){
  923.                         return true;
  924.                     }
  925.                 }
  926.             }
  927.             else{
  928.                 throw new ExpressionException(FIELD_TYPE_UNKNOWN_PREFIX+iField.getClass().getName()+"]");
  929.             }
  930.         
  931.             
  932.         }
  933.         
  934.         return useModelExpressionBase;
  935.         
  936.     }
  937.     private static boolean inUseEngine(IModel<?> model,IField field){
  938.         boolean inUse = false;
  939.         if(model.getBaseField()!=null){
  940.             // Modello di un elemento non radice
  941.             if(field instanceof ComplexField){
  942.                 ComplexField c = (ComplexField) field;
  943.                 inUse = c.getFather().equals(model.getBaseField());
  944.             }else{
  945.                 String modeClassName = model.getModeledClass().getName() + "";
  946.                 inUse = modeClassName.equals(field.getClassType().getName());
  947.             }
  948.         }
  949.         else{
  950.             String modeClassName = model.getModeledClass().getName() + "";
  951.             inUse = modeClassName.equals(field.getClassType().getName());
  952.         }
  953.         return inUse;
  954.     }
  955.     
  956.     protected static List<IField> getFields(boolean onlyWhereCondition, 
  957.             List<IField> getFieldExpressionBase,List<Object> fieldsManuallyAdd,boolean checkFieldManuallyAdd) throws ExpressionException {
  958.         if(!checkFieldManuallyAdd){
  959.             return getFieldExpressionBase;
  960.         }
  961.         if(onlyWhereCondition){
  962.             return getFieldExpressionBase;
  963.         }
  964.         List<IField> newFields = new ArrayList<>();
  965.         if(getFieldExpressionBase!=null){
  966.             newFields.addAll(getFieldExpressionBase);
  967.         }
  968.         for (Object iField : fieldsManuallyAdd) {
  969.             IField field = null;
  970.             if(iField instanceof IField){
  971.                 field = (IField) iField;
  972.                 if(getFieldExpressionBase==null || (!getFieldExpressionBase.contains(field))){
  973.                     newFields.add(field);
  974.                 }
  975.             }
  976.             else if(iField instanceof FunctionField){
  977.                 List<IField> fieldsFF = ((FunctionField) iField).getFields();
  978.                 for (IField iFieldFF : fieldsFF) {
  979.                     if(getFieldExpressionBase==null || (!getFieldExpressionBase.contains(iFieldFF))){
  980.                         newFields.add(iFieldFF);
  981.                     }
  982.                 }
  983.             }
  984.             else{
  985.                 throw new ExpressionException(FIELD_TYPE_UNKNOWN_PREFIX+iField.getClass().getName()+"]");
  986.             }
  987.         
  988.         }   
  989.         return newFields;
  990.     }
  991.     
  992.     
  993.     
  994.     
  995.     /* ************ TO SQL *********** */
  996.     
  997.     public String toSql() throws ExpressionException{
  998.         if(this.expressionEngine==null &&
  999.             this.throwExpressionNotInitialized){
  1000.             throw new ExpressionException(EXPRESSION_NOT_INITIALIZED);
  1001.         }
  1002.         
  1003.         StringBuilder bf = null;
  1004.         if(this.expressionEngine==null){
  1005.             bf = new StringBuilder("");
  1006.         }
  1007.         else if(this.expressionEngine instanceof ISQLExpression){
  1008.             bf = new StringBuilder(((ISQLExpression)this.expressionEngine).toSql());
  1009.         }else{
  1010.             throw new ExpressionException(EXPRESSION_TYPE_PREFIX+this.expressionEngine.getClass().getName()+IS_NOT_AS_CAST_WITH+ISQLExpression.class.getName());
  1011.         }
  1012.         
  1013.         bf.append(toSqlGroupBy());
  1014.         bf.append(toSqlOrder());
  1015.         bf.append(toSqlForceIndex()); // Lo metto in fondo tanto sono commenti
  1016.         
  1017.         return bf.toString();
  1018.     }
  1019.     protected String toSqlPreparedStatement(List<Object> oggetti) throws ExpressionException {
  1020.         if(this.expressionEngine==null &&
  1021.             this.throwExpressionNotInitialized){
  1022.             throw new ExpressionException(EXPRESSION_NOT_INITIALIZED);
  1023.         }
  1024.         
  1025.         StringBuilder bf = null;
  1026.         if(this.expressionEngine==null){
  1027.             bf = new StringBuilder("");
  1028.         }
  1029.         else if(this.expressionEngine instanceof ISQLExpression){
  1030.             bf = new StringBuilder(((ISQLExpression)this.expressionEngine).toSqlPreparedStatement(oggetti));
  1031.         }else{
  1032.             throw new ExpressionException(EXPRESSION_TYPE_PREFIX+this.expressionEngine.getClass().getName()+IS_NOT_AS_CAST_WITH+ISQLExpression.class.getName());
  1033.         }
  1034.         
  1035.         bf.append(toSqlGroupBy());
  1036.         bf.append(toSqlOrder());
  1037.         bf.append(toSqlForceIndex()); // Lo metto in fondo tanto sono commenti
  1038.         
  1039.         return bf.toString();
  1040.     }

  1042.     protected String toSqlJPA(Map<String, Object> oggetti) throws ExpressionException {
  1043.         if(this.expressionEngine==null &&
  1044.             this.throwExpressionNotInitialized){
  1045.             throw new ExpressionException(EXPRESSION_NOT_INITIALIZED);
  1046.         }
  1047.         
  1048.         StringBuilder bf = null;
  1049.         if(this.expressionEngine==null){
  1050.             bf = new StringBuilder("");
  1051.         }else if(this.expressionEngine instanceof ISQLExpression){
  1052.             bf = new StringBuilder(((ISQLExpression)this.expressionEngine).toSqlJPA(oggetti));
  1053.         }else{
  1054.             throw new ExpressionException(EXPRESSION_TYPE_PREFIX+this.expressionEngine.getClass().getName()+IS_NOT_AS_CAST_WITH+ISQLExpression.class.getName());
  1055.         }
  1056.         
  1057.         bf.append(toSqlGroupBy());
  1058.         bf.append(toSqlOrder());
  1059.         bf.append(toSqlForceIndex()); // Lo metto in fondo tanto sono commenti
  1060.         
  1061.         return bf.toString();
  1062.     }
  1063.     
  1064.     public void toSql(ISQLQueryObject sqlQueryObject)throws ExpressionException{
  1065.         if(this.expressionEngine==null &&
  1066.             this.throwExpressionNotInitialized){
  1067.             throw new ExpressionException(EXPRESSION_NOT_INITIALIZED);
  1068.         }
  1069.         if(this.expressionEngine==null){            
  1070.             // nop
  1071.         }
  1072.         else if(this.expressionEngine instanceof ISQLExpression){
  1073.             ((ISQLExpression)this.expressionEngine).toSql(sqlQueryObject);
  1074.         }else{
  1075.             throw new ExpressionException(EXPRESSION_TYPE_PREFIX+this.expressionEngine.getClass().getName()+IS_NOT_AS_CAST_WITH+ISQLExpression.class.getName());
  1076.         }
  1077.         
  1078.         // GroupBy
  1079.         toSqlGroupBy(sqlQueryObject);
  1080.         
  1081.         // OrderBy
  1082.         toSqlOrder(sqlQueryObject);
  1083.         
  1084.         // Aggiungo select field relativi all'aggregazione
  1085.         toSqlGroupBySelectField(sqlQueryObject);
  1086.         
  1087.         // ForceIndex
  1088.         toSqlForceIndex(sqlQueryObject);
  1089.     }
  1090.     
  1091.     public void toSqlWithFromCondition(ISQLQueryObject sqlQueryObject,String tableNamePrincipale) throws ExpressionException, ExpressionNotImplementedException{
  1092.         
  1093.         // preparo condizione di where
  1094.         this.toSql(sqlQueryObject);
  1095.         
  1096.         // aggiungo condizione di from
  1097.         sqlFrom(sqlQueryObject, this.getFields(false), this.getSqlFieldConverter(), tableNamePrincipale, this.getFieldsManuallyAdd(),
  1098.                 this.getOrderedFields(),this.getGroupByFields());
  1099.     }
  1100.     
  1101.     protected void toSqlPreparedStatement(ISQLQueryObject sqlQueryObject,List<Object> oggetti)throws ExpressionException{
  1102.         if(this.expressionEngine==null &&
  1103.             this.throwExpressionNotInitialized){
  1104.             throw new ExpressionException(EXPRESSION_NOT_INITIALIZED);
  1105.         }
  1106.         if(this.expressionEngine==null){        
  1107.             // nop
  1108.         }
  1109.         else if(this.expressionEngine instanceof ISQLExpression){
  1110.             ((ISQLExpression)this.expressionEngine).toSqlPreparedStatement(sqlQueryObject,oggetti);
  1111.         }else{
  1112.             throw new ExpressionException(EXPRESSION_TYPE_PREFIX+this.expressionEngine.getClass().getName()+IS_NOT_AS_CAST_WITH+ISQLExpression.class.getName());
  1113.         }
  1114.         
  1115.         // GroupBy
  1116.         toSqlGroupBy(sqlQueryObject);
  1117.         
  1118.         // OrderBy
  1119.         toSqlOrder(sqlQueryObject);
  1120.         
  1121.         // Aggiungo select field relativi all'aggregazione
  1122.         toSqlGroupBySelectField(sqlQueryObject);
  1123.         
  1124.         // ForceIndex
  1125.         toSqlForceIndex(sqlQueryObject);
  1126.     }
  1127.     
  1128.     protected void toSqlPreparedStatementWithFromCondition(ISQLQueryObject sqlQueryObject,List<Object> oggetti,String tableNamePrincipale) throws ExpressionException, ExpressionNotImplementedException{
  1129.         
  1130.         // preparo condizione di where
  1131.         this.toSqlPreparedStatement(sqlQueryObject, oggetti);
  1132.         
  1133.         // aggiungo condizione di from
  1134.         sqlFrom(sqlQueryObject, this.getFields(false), this.getSqlFieldConverter(), tableNamePrincipale, this.getFieldsManuallyAdd(),
  1135.                 this.getOrderedFields(),this.getGroupByFields());
  1136.     }
  1137.     
  1138.     protected void toSqlJPA(ISQLQueryObject sqlQueryObject,Map<String, Object> oggetti)throws ExpressionException{
  1139.         if(this.expressionEngine==null &&
  1140.             this.throwExpressionNotInitialized){
  1141.             throw new ExpressionException(EXPRESSION_NOT_INITIALIZED);
  1142.         }
  1143.         
  1144.         if(this.expressionEngine==null){    
  1145.             // nop
  1146.         }
  1147.         else if(this.expressionEngine instanceof ISQLExpression){
  1148.             ((ISQLExpression)this.expressionEngine).toSqlJPA(sqlQueryObject,oggetti);
  1149.         }else{
  1150.             throw new ExpressionException(EXPRESSION_TYPE_PREFIX+this.expressionEngine.getClass().getName()+IS_NOT_AS_CAST_WITH+ISQLExpression.class.getName());
  1151.         }
  1152.         
  1153.         // GroupBy
  1154.         toSqlGroupBy(sqlQueryObject);
  1155.         
  1156.         // OrderBy
  1157.         toSqlOrder(sqlQueryObject);
  1158.                 
  1159.         // Aggiungo select field relativi all'aggregazione
  1160.         toSqlGroupBySelectField(sqlQueryObject);
  1161.         
  1162.         // ForceIndex
  1163.         toSqlForceIndex(sqlQueryObject);
  1164.     }
  1165.     
  1166.     protected void toSqlJPAWithFromCondition(ISQLQueryObject sqlQueryObject,Map<String, Object> oggetti,String tableNamePrincipale) throws ExpressionException, ExpressionNotImplementedException{
  1167.         
  1168.         // preparo condizione di where
  1169.         this.toSqlJPA(sqlQueryObject, oggetti);
  1170.         
  1171.         // aggiungo condizione di from
  1172.         sqlFrom(sqlQueryObject, this.getFields(false), this.getSqlFieldConverter(), tableNamePrincipale, this.getFieldsManuallyAdd(),
  1173.                 this.getOrderedFields(),this.getGroupByFields());
  1174.     }
  1175.     
  1176.     public void addField(ISQLQueryObject sqlQueryObject, IField field, boolean appendTablePrefix)throws ExpressionException{
  1177.         ExpressionSQL.addFieldEngine(sqlQueryObject,this.getSqlFieldConverter(),field, null, appendTablePrefix);
  1178.         this.getFieldsManuallyAdd().add(field);
  1179.     }
  1180.     public void addField(ISQLQueryObject sqlQueryObject, IField field, String aliasField, boolean appendTablePrefix)throws ExpressionException{
  1181.         ExpressionSQL.addFieldEngine(sqlQueryObject,this.getSqlFieldConverter(),field, aliasField, appendTablePrefix);
  1182.         this.getFieldsManuallyAdd().add(field);
  1183.     }
  1184.     public void addAliasField(ISQLQueryObject sqlQueryObject, IField field, boolean appendTablePrefix)throws ExpressionException{
  1185.         ExpressionSQL.addAliasFieldEngine(sqlQueryObject,this.getSqlFieldConverter(),field, null, appendTablePrefix);
  1186.         this.getFieldsManuallyAdd().add(field);
  1187.     }
  1188.     public void addField(ISQLQueryObject sqlQueryObject, FunctionField field, boolean appendTablePrefix)throws ExpressionException{
  1189.         ExpressionSQL.addFieldEngine(sqlQueryObject,this.getSqlFieldConverter(),field, null, appendTablePrefix);
  1190.         this.getFieldsManuallyAdd().add(field);
  1191.     }
  1192.     
  1193.     
  1194.     /* ************ OBJECTS ************ */
  1195.     @Override
  1196.     protected ComparatorExpressionImpl getComparatorExpression(IField field, Object value, Comparator c) {
  1197.         return new ComparatorExpressionSQL(this.sqlFieldConverter,this.objectFormatter,field,value,c);
  1198.     }
  1199.     @Override
  1200.     protected BetweenExpressionImpl getBetweenExpression(IField field, Object lower, Object high) {
  1201.         return new BetweenExpressionSQL(this.sqlFieldConverter,this.objectFormatter,field,lower,high);
  1202.     }
  1203.     @Override
  1204.     protected InExpressionImpl getInExpression(IField field, Object... values) {
  1205.         List<Object> lista = new ArrayList<>();
  1206.         if(values!=null && values.length>0){
  1207.             lista.addAll(Arrays.asList(values));
  1208.         }
  1209.         return new InExpressionSQL(this.sqlFieldConverter,this.objectFormatter,field, lista);
  1210.     }
  1211.     @Override
  1212.     protected LikeExpressionImpl getLikeExpression(IField field, String value, LikeMode mode, boolean caseInsensitive) {
  1213.         return new LikeExpressionSQL(this.sqlFieldConverter,this.objectFormatter,field, value, mode, caseInsensitive);
  1214.     }
  1215.     @Override
  1216.     protected DateTimePartExpressionImpl getDateTimePartExpression(IField field, String value, DateTimePartEnum dateTimePartEnum) {
  1217.         return new DateTimePartExpressionSQL(this.sqlFieldConverter,this.objectFormatter,field, value, dateTimePartEnum);
  1218.     }
  1219.     @Override
  1220.     protected DayFormatExpressionImpl getDayFormatExpression(IField field, String value, DayFormatEnum dayFormatEnum) {
  1221.         return new DayFormatExpressionSQL(this.sqlFieldConverter,this.objectFormatter,field, value, dayFormatEnum);
  1222.     }
  1223.     @Override
  1224.     protected ConjunctionExpressionImpl getConjunctionExpression() {
  1225.         return new ConjunctionExpressionSQL(this.sqlFieldConverter,this.objectFormatter);
  1226.     }
  1227.     
  1228. }
Created with JaCoCo 0.8.8.202204050719