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

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

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

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

        return env;

    }

    public String getSQL() {

        if (this.helper.hasSpatialFunctions()) {

            return getSQLWithAggregate();

        } else {

            return getSQLWihoutAggregate();

        }

    }

    public String getSQLWihoutAggregate() {

        //Crear un select que devuelve todas las lineas

        JDBCSQLBuilderBase sqlbuilder = this.createSQLBuilder();

        GeometryExpressionBuilder expbuilder = sqlbuilder.expression();

        sqlbuilder.select().column().name(columnName).as_geometry();

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

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

        }

        // todo ?

        sqlbuilder.select().where().and(expbuilder.not_is_null(expbuilder.column(columnName)));

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

        return sql;

    }

    public String getSQLWithAggregate() {

        //

        // 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();

        GeometryExpressionBuilder 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.processSpecialFunctions(sqlbuilder, featureType, null);

        sqlbuilder.setProperties(

                Variable.class,

                PROP_TABLE, table

        );

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

        return sql;

    }

    public Envelope calculateEnvelopeOfColumn(Connection conn) throws DataException {

        if (this.helper.hasSpatialFunctions()) {

            return calculateEnvelopeOfColumnWithAggregate(conn);

        } else {

            return calculateEnvelopeOfColumnWithoutAggregate(conn);

        }

    }

    private Envelope calculateEnvelopeOfColumnWithAggregate(Connection conn) throws DataException {

        String sql = this.getSQL();

        Statement st = null;

        ResultSet rs = null;

        try {

            st = conn.createStatement();

            try {

                LOGGER.debug("execute query SQL:" + sql);

                rs = st.executeQuery(sql);

                // No llamo al de JDBC utils para que no meta el error

                // en el log.

                // rs = JDBCUtils.executeQuery(st, sql);

            } catch (SQLException ex) {

//                Para calcular el envelope se esta lanzando una colsulta como:

//                   SELECT ST_AsBinary(ST_Extent("geometry")) 

//                   FROM "gis_osm_roads_free_1" 

//                   WHERE ( ("geometry") IS NOT NULL )

//                Que falla cuando no hay registros al recibir un NULL en el 

//                ST_AsBinary. 

//                A falta de una forma mejor de detectar eso, si peta en este

//                punto asumiremos que no hay registros en la consulta y devolveremos

//                null como envelope.

                return null;

            }

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

        }

    }

    private Envelope calculateEnvelopeOfColumnWithoutAggregate(Connection conn) throws DataException {

//        crear una sql que devuelva un resultarSet

//bucle

//        iif instacia de string: cast string

//        GeometryLocator.getGeometryManager().createFrom("")

//        elif instance de bytearray con cast a bytearray:

//         GeometryLocator.getGeometryManager().createFrom("")    

//                 else:

//                 coerceToGeometry

//                         

//                         

//                         Notas: atrapar error, y si se produce error hago un coerceToGeometry       

        String sql = this.getSQL();

        Statement st = null;

        ResultSet rs = null;

        try {

            st = conn.createStatement();

            try {

                LOGGER.debug("execute query SQL:" + sql);

                rs = st.executeQuery(sql);

                // No llamo al de JDBC utils para que no meta el error

                // en el log.

                // rs = JDBCUtils.executeQuery(st, sql);

            } catch (SQLException ex) {

//                Para calcular el envelope se esta lanzando una colsulta como:

//                   SELECT ST_AsBinary(ST_Extent("geometry")) 

//                   FROM "gis_osm_roads_free_1" 

//                   WHERE ( ("geometry") IS NOT NULL )

//                Que falla cuando no hay registros al recibir un NULL en el 

//                ST_AsBinary. 

//                A falta de una forma mejor de detectar eso, si peta en este

//                punto asumiremos que no hay registros en la consulta y devolveremos

//                null como envelope.

                return null;

            }

            Envelope finalEnvelope = GeometryUtils.createEnvelope(Geometry.SUBTYPES.GEOM2D);

            while (rs.next()) {

                String geometryString = rs.getString("geometry");

                Geometry geometry = GeometryUtils.createFrom(geometryString);

                finalEnvelope.add(geometry);

            }

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

//            if (geom == null) {

//                return null;

//            }

//            return geom.getEnvelope();

            return finalEnvelope;

        } catch (SQLException ex) {

            throw new JDBCSQLException(ex);

        } finally {

            JDBCUtils.closeQuietly(st);

            JDBCUtils.closeQuietly(rs);

        }

    }

}