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.fmap.dal.ExpressionBuilder.Config;

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.ResulSetControler.ResultSetEntry;

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

import org.gvsig.fmap.geom.DataTypes;

import org.gvsig.tools.evaluator.Evaluator;

public class ResultSetForSetProviderOperation extends AbstractConnectionOperation {

    private final String schema;

    private final String table;

    private final String subquery;

    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;

    private final String database;

    public ResultSetForSetProviderOperation(

            JDBCHelper helper,

            String database,

            String schema,

            String table,

            String subquery,

            String baseFilter,

            String baseOrder,

            FeatureQuery query,

            FeatureType storeType,

            FeatureType setType,

            long limit,

            long offset,

            int fetchSize

        ) {

        super(helper);

        this.database = database;

        this.schema = schema;

        this.table = table;

        this.subquery = subquery;

        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(

                database, schema, table, subquery, 

                baseFilter, baseOrder, storeType, setType, query, 

                limit, offset, fetchSize);

        return rs;

    }

    @Override

    public Object perform(Connection conn) throws DataException {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    public ResultSetEntry createResultSet(

            String database,

            String schema,

            String table,

            String subquery,

            String baseFilter,

            String baseOrder,

            FeatureType storeType,

            FeatureType setType,

            FeatureQuery query,

            long limit,

            long offset,

            int fetchSize

        ) throws DataException {

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

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

        JDBCSQLBuilderBase sqlbuilder = createSQLBuilder();

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

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

            primaryKeys.add(attr.getName());

        }

        for(String attrName : primaryKeys ) {

            // Ordenamos siempre por las claves primarias para garantizar 

            // un orden predecible. Ademas se precisa indicar un orden para

            // usar OFFSET.

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

        }

        String[] constantsAttributeNames = null;

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

            constantsAttributeNames = query.getConstantsAttributeNames();

        }

        for(FeatureAttributeDescriptor attr : setType ) {

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

                continue;

            }

            if( attr.isPrimaryKey() ) {

                primaryKeys.remove(attr.getName());

            }

            if( attr.getType() == DataTypes.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);

            }

        }

        for(String attrName : primaryKeys ) {

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

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

        }

        if( StringUtils.isEmpty(subquery)  ) {

            sqlbuilder.select().from().table().database(database).schema(schema).name(table);

        } else {

            sqlbuilder.select().from().subquery(subquery);

        }

        Evaluator filter = query.getFilter();

        if( filter != null ) {

            String sqlfilter = filter.getSQL();

            if( ! StringUtils.isEmpty(sqlfilter) ) {

                sqlbuilder.select().where().set( sqlbuilder.custom(sqlfilter) );

            }

        }

        if( ! StringUtils.isEmpty(baseFilter) ) {

            sqlbuilder.select().where().and(sqlbuilder.custom(baseFilter));

        }

        FeatureQueryOrder order = 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( limit > 0 ) {

            sqlbuilder.select().limit(limit);

        } else {

            sqlbuilder.select().limit(query.getLimit());

        }

        if( offset>0 ) {

            sqlbuilder.select().offset(offset);

        }

        String sql = sqlbuilder.toString();

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

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

        );

        return resultSetEntry;

    }

}