Application: gvSIG desktop

package org.gvsig.fmap.dal.store.jdbc2.spi.operations;

import java.sql.Connection;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.SQLBuilder.SelectBuilder;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureQuery;

import org.gvsig.fmap.dal.feature.FeatureQueryOrder;

import org.gvsig.fmap.dal.feature.FeatureQueryOrder.FeatureQueryOrderMember;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.store.jdbc2.JDBCHelper;

import org.gvsig.fmap.dal.store.jdbc2.OperationsFactory.TableReference;

import org.gvsig.fmap.dal.store.jdbc2.ResulSetControler.ResultSetEntry;

import org.gvsig.fmap.dal.store.jdbc2.spi.JDBCSQLBuilderBase;

import static org.gvsig.fmap.dal.store.jdbc2.spi.JDBCSQLBuilderBase.PROP_FEATURE_TYPE;

import static org.gvsig.fmap.dal.store.jdbc2.spi.JDBCSQLBuilderBase.PROP_TABLE;

import org.gvsig.fmap.geom.DataTypes;

import org.gvsig.tools.evaluator.Evaluator;

public class ResultSetForSetProviderOperation extends AbstractConnectionOperation {

    private final TableReference table;

    private final String baseFilter;

    private final String baseOrder;

    private final FeatureType storeType;

    private final FeatureType setType;

    private final FeatureQuery query;

    private final long limit;

    private final long offset;

    private final int fetchSize;

    public ResultSetForSetProviderOperation(

            JDBCHelper helper,

            TableReference table,

            String baseFilter,

            String baseOrder,

            FeatureQuery query,

            FeatureType storeType,

            FeatureType setType,

            long limit,

            long offset,

            int fetchSize

        ) {

        super(helper);

        this.table = table;

        this.baseFilter = baseFilter;

        this.baseOrder = baseOrder;

        this.storeType = storeType;

        this.setType = setType;

        this.query = query;

        this.limit = limit;

        this.offset = offset;

        this.fetchSize = fetchSize; 

    }

    @Override

    protected Object perform_operation() throws Exception {

        ResultSetEntry rs = createResultSet();

        return rs;

    }

    @Override

    public Object perform(Connection conn) throws DataException {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    public String getSQL() {

        List<FeatureAttributeDescriptor> columns = new ArrayList<>();

        JDBCSQLBuilderBase sqlbuilder = createSQLBuilder();

        String sql = this.getSQL(sqlbuilder, columns, null);

        return sql;

    }

    public String getSQL(

            JDBCSQLBuilderBase sqlbuilder, 

            List<FeatureAttributeDescriptor> columns, 

            List<String> extraColumnNames

      ) {

        double tolerance = -1 ; //query.getScale();

        ExpressionBuilder expbuilder = sqlbuilder.expression();

        SelectBuilder select = sqlbuilder.select();

        List<String> primaryKeys = new ArrayList<>();

        for(FeatureAttributeDescriptor attr : storeType.getPrimaryKey() ) {

            primaryKeys.add(attr.getName());

        }

        List<String> forcedColumns = new ArrayList<>(primaryKeys);

        String[] constantsAttributeNames = null;

        if(query !=null && query.hasConstantsAttributeNames() ) {

            constantsAttributeNames = query.getConstantsAttributeNames();

        }

        for(FeatureAttributeDescriptor attr : setType ) {

            if( attr.isComputed() ) {

                continue;

            }

            if( ArrayUtils.contains(constantsAttributeNames, attr.getName()) ) {

                continue;

            }

            if( attr.isPrimaryKey() ) {

                forcedColumns.remove(attr.getName());

            }

            if( query !=null && query.hasGroupByColumns()) {

              String aggregate = query.getAggregate(attr.getName());

              if( this.query.isAGroupByColumn(attr.getName()) ) {

                  select.column().name(attr.getName());

              } else if( aggregate == null ) {

                select.column().value(expbuilder.constant(null)).as(attr.getName());

              } else {

                select.column()

                        .value(ExpressionUtils.compile(aggregate).toValue(expbuilder))

                        .as(attr.getName());

              }

            } else {

              if( attr.getType() == DataTypes.GEOMETRY ) {

                  select.column().name(attr.getName()).as_geometry();

  //                if( tolerance<=0 || !sqlbuilder.getConfig().has_functionality(Config.ST_Simplify)) {

  //                    select.column().name(attr.getName()).as_geometry();

  //                } else {

  //                    select.column().value(

  //                        sqlbuilder.ST_Simplify( 

  //                            sqlbuilder.column(attr.getName()),

  //                            sqlbuilder.constant(tolerance)

  //                        )

  //                    ).as_geometry();

  //                }

              } else {

                  select.column().name(attr.getName());

              }

            }

            columns.add(attr);

        }

        if( query !=null && query.hasGroupByColumns() ) {

            for(String attrName : query.getGroupByColumns() ) {

                select.group_by(expbuilder.column(attrName));

            }

        } else {

            for(String attrName : forcedColumns ) {

                select.column().name(attrName);

                columns.add(setType.getAttributeDescriptor(attrName));

            }

        }

        select.from().table()

                .database(this.table.getDatabase())

                .schema(this.table.getSchema())

                .name(this.table.getTable());

        select.from().subquery(this.table.getSubquery());

        Evaluator filter = query==null? null:query.getFilter();

        if( filter != null ) {

            String sqlfilter = filter.getSQL();

            if( ! StringUtils.isEmpty(sqlfilter) ) {

                if( this.helper.supportFilter(this.storeType, filter) ) {

                    select.where().set(expbuilder.toValue(sqlfilter));

                }

            }

        }

        if( ! StringUtils.isEmpty(baseFilter) ) {

            select.where().and(expbuilder.toValue(baseFilter));

        }

        FeatureQueryOrder order = query==null? null:query.getOrder();

        if( order != null ) {

            for( FeatureQueryOrderMember member : order.members() ) {

                if( member.hasEvaluator() ) {

                    String sqlorder = member.getEvaluator().getSQL();

                    if( ! StringUtils.isEmpty(sqlorder) ) {

                        select.order_by().custom(sqlorder);

                    }

                } else {

                    select.order_by()

                            .column(member.getAttributeName())

                            .ascending(member.getAscending());

                }

            }

        }

        if( !StringUtils.isEmpty(baseOrder) ) {

            select.order_by().custom(baseOrder);

        }

        if( !select.has_order_by() ) {        

          // Si no tenemos order by comprobamos si lo necesitamos y lo a?adimos.

          if( offset>0 || (offset==0 && limit>0) ) {

              // No tengo claro que (offset==0 && limit>0) sea lo mas correcto,

              // Pero cuando se va a paginar y se pide la primera pagina offset es

              // 0 y limit>0, y si no ordenamos ya esa primera pagina los resultados

              // que se obtienen no son correctos, ya que la primera pagina se saca

              // sin ordenar y el resto ordenadas.

              // Probablemente deberiamos tener alguna otra forma de detectar que

              // estamos paginanado ya que asi no distinguimo si solo queremos 

              // obtener los primeros elementos sin importarnos su orden.

              if( primaryKeys.isEmpty() ) {

                // Muy probablemente si no tiene pk sea una vista, asi que 

                // pasaremos de ordenar y esperemos que la vista este ya ordenada.

                select.disable_check_order_and_offset();

              } else {

                for(String attrName : primaryKeys ) {

                    // Se precisa indicar un orden para usar OFFSET.

                    select.order_by().column(sqlbuilder.as_identifier(attrName)).ascending();

                }

              }

          }            

        }        

        if( limit > 0 ) {

            select.limit(limit);

        } else {

            select.limit(query==null? null:query.getLimit());

        }

        if( offset>0 ) {

            select.offset(offset);

        }        

        sqlbuilder.setProperties(

                null, 

                PROP_FEATURE_TYPE, this.storeType,

                PROP_TABLE, table

        );        

        this.helper.processSpecialFunctions(sqlbuilder, storeType, extraColumnNames);

        String sql = sqlbuilder.toString();

        return sql;

    }

    public ResultSetEntry createResultSet() throws DataException {

        List<FeatureAttributeDescriptor> columns = new ArrayList<>();

        List<String> extraColumnNames = new ArrayList<>();

        JDBCSQLBuilderBase sqlbuilder = createSQLBuilder();

        String sql = this.getSQL(sqlbuilder, columns, extraColumnNames);

        ResultSetEntry resultSetEntry = this.helper.getResulSetControler().create(

                sql, fetchSize, 

                columns.toArray(new FeatureAttributeDescriptor[columns.size()]),

                extraColumnNames.toArray(new String[extraColumnNames.size()])

        );

        return resultSetEntry;

    }

}