Application: gvSIG desktop

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

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionBuilder.Variable;

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

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

import org.gvsig.fmap.dal.store.jdbc.exception.JDBCSQLException;

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.primitive.Envelope;

public class CalculateEnvelopeOfColumnOperation extends AbstractConnectionOperation {

    private final TableReference table;

    private final String columnName;

    private final String baseFilter;

    private final Envelope limit;

    private final IProjection crs;

    private final FeatureType featureType;

    public CalculateEnvelopeOfColumnOperation(

            JDBCHelper helper,

            FeatureType featureType,

            TableReference table,

            String columnName,

            String baseFilter,

            Envelope limit,

            IProjection crs

    ) {

        super(helper);

        this.featureType = featureType;

        this.table = table;

        this.columnName = columnName;

        this.baseFilter = baseFilter;

        this.limit = limit;

        this.crs = crs;

    }

    @Override

    public final Object perform(Connection conn) throws DataException {

        Envelope env = calculateEnvelopeOfColumn(

            conn,

            featureType,

            table,

            columnName,

            baseFilter,

            limit,

            crs

        );

        return env;

    }

    public Envelope calculateEnvelopeOfColumn(

            Connection conn,

            FeatureType featureType,

            TableReference table,

            String columnName,

            String baseFilter,

            Envelope limit,

            IProjection crs

    ) throws DataException {

        //

        // Parece ser que en versiones anteriores a SQL Server 2012 no esta

        // disponible la funcion ST_ExtentAggregate.

        // Habria que determinar si es necesario implementar una alternativa

        // para estos casos.

        //

        // https://alastaira.wordpress.com/2011/07/26/determining-the-geographic-extent-of-spatial-features-in-a-sql-server-table/

        //

        JDBCSQLBuilderBase sqlbuilder = this.createSQLBuilder();

        ExpressionBuilder expbuilder = sqlbuilder.expression();

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

//            expbuilder.ifnull(

//                expbuilder.column(columnName), 

//                expbuilder.constant(null), 

                expbuilder.as_geometry(

                    expbuilder.ST_ExtentAggregate(

                            expbuilder.column(columnName)

                    )

                )

//            )

        );

//        sqlbuilder.select().group_by(expbuilder.column(columnName));

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

                .database(this.table.getDatabase())

                .schema(this.table.getSchema())

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

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

        if (StringUtils.isEmpty(baseFilter)) {

            if (limit != null) {

                sqlbuilder.select().where().set(

                        expbuilder.ST_Intersects(

                                expbuilder.ST_Envelope(

                                        expbuilder.column(columnName)

                                ),

                                expbuilder.ST_Envelope(

                                        expbuilder.geometry(limit.getGeometry(), crs)

                                )

                        )

                );

            }

        } else {

            sqlbuilder.select().where().set( expbuilder.custom(baseFilter) );

            if (limit != null) {

                sqlbuilder.select().where().and(

                        expbuilder.ST_Intersects(

                            expbuilder.ST_Envelope(

                                    expbuilder.column(columnName)

                            ),

                            expbuilder.ST_Envelope(

                                    expbuilder.geometry(limit.getGeometry(), crs)

                            )

                        )

                );

            }

        }

        sqlbuilder.select().where().and(        

            expbuilder.not_is_null(expbuilder.column(columnName))

        );

        this.helper.replaceForeingValueFunction(sqlbuilder, featureType);

        sqlbuilder.setProperties(

                Variable.class, 

                PROP_TABLE, table

        );

        String sql = sqlbuilder.select().toString();

        Statement st = null;

        ResultSet rs = null;

        try {

            st = conn.createStatement();

            rs = JDBCUtils.executeQuery(st, sql);

            if (!rs.next()) {

                return null;

            }

            Geometry geom = this.helper.getGeometryFromColumn(rs, 1);

            if (geom == null) {

                return null;

            }

            return geom.getEnvelope();

        } catch (SQLException ex) {

            throw new JDBCSQLException(ex);

        } finally {

            JDBCUtils.closeQuietly(st);

            JDBCUtils.closeQuietly(rs);

        }

    }

}