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.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);

        return sql;

    }

    public String getSQL(JDBCSQLBuilderBase sqlbuilder, List<FeatureAttributeDescriptor> columns) {

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

        ExpressionBuilder expbuilder = sqlbuilder.expression();

        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( attr.getType() == DataTypes.GEOMETRY ) {

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

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

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

//                } else {

//                    sqlbuilder.select().column().value(

//                        sqlbuilder.ST_Simplify( 

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

//                            sqlbuilder.constant(tolerance)

//                        )

//                    ).as_geometry();

//                }

                columns.add(attr);

            } else {

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

                columns.add(attr);

            }

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

                sqlbuilder.select().group_by(expbuilder.column(attr.getName()));

            }

        }

        if( query ==null || !query.isGrouped() ) {

            for(String attrName : forcedColumns ) {

                sqlbuilder.select().column().name(attrName);

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

            }

        }

        sqlbuilder.select().from().table()

                .database(this.table.getDatabase())

                .schema(this.table.getSchema())

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

        sqlbuilder.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) ) {

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

                }

            }

        }

        if( ! StringUtils.isEmpty(baseFilter) ) {

            sqlbuilder.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) ) {

                        sqlbuilder.select().order_by()

                                .custom(sqlorder);

                    }

                } else {

                    sqlbuilder.select().order_by()

                            .column(member.getAttributeName())

                            .ascending(member.getAscending());

                }

            }

        }

        if( !StringUtils.isEmpty(baseOrder) ) {

            sqlbuilder.select().order_by().custom(baseOrder);

        }

        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.

            for(String attrName : primaryKeys ) {

                // Se precisa indicar un orden para usar OFFSET.

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

            }

        }        

        if( limit > 0 ) {

            sqlbuilder.select().limit(limit);

        } else {

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

        }

        if( offset>0 ) {

            sqlbuilder.select().offset(offset);

        }        

        sqlbuilder.setProperties(

                null, 

                PROP_FEATURE_TYPE, this.storeType,

                PROP_TABLE, table

        );

        String sql = sqlbuilder.toString();

        return sql;

    }

    public ResultSetEntry createResultSet() throws DataException {

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

        JDBCSQLBuilderBase sqlbuilder = createSQLBuilder();

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

        String[] extraColumnNames = this.helper.replaceForeingValueFunction(sqlbuilder, storeType);

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

                sql, fetchSize, 

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

                extraColumnNames

        );

        return resultSetEntry;

    }

}