Application: gvSIG desktop

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

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

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

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

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

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureReferenceProviderServices;

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.spi.JDBCSQLBuilderBase;

import org.gvsig.fmap.geom.DataTypes;

public class FetchFeatureProviderByReferenceOperation extends AbstractConnectionOperation {

    private final FeatureType featureType;

    private final FeatureReferenceProviderServices reference;

    private final String schema;

    private final String table;

    private final String database;

    public FetchFeatureProviderByReferenceOperation(

            JDBCHelper helper,

            FeatureReferenceProviderServices reference,

            FeatureType featureType,

            String database,

            String schema,

            String table

        ) {

        super(helper);

        this.reference = reference;

        this.database = database;

        this.schema = schema;

        this.table = table;

        this.featureType = featureType;

    }

    @Override

    public final Object perform(Connection conn) throws DataException {

        FeatureProvider feature = fetchFeatureProviderByReference(

                conn,

                reference,

                featureType,

                database,

                schema,

                table

        );

        return feature;

    }

    public FeatureProvider fetchFeatureProviderByReference(

            Connection conn,

            FeatureReferenceProviderServices reference,

            // FeatureType storeType,

            FeatureType featureType,

            String database,

            String schema,

            String table

        ) throws DataException {

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

        // FeatureAttributeDescriptor[] primaryKey = storeType.getPrimaryKey();

        String[] primaryKeys = reference.getKeyNames();

        JDBCSQLBuilderBase sqlbuilder = this.createSQLBuilder();

        for (FeatureAttributeDescriptor attr : featureType) {

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

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

                columns.add(attr);

            } else {

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

                columns.add(attr);

            }

        }

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

        for (String name : primaryKeys )  {

            if( !sqlbuilder.select().has_column(name) ) {

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

                columns.add(featureType.getAttributeDescriptor(name));

            }

            Object value = reference.getKeyValue(name);

            if( value == null ) {

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

                    sqlbuilder.isNull(sqlbuilder.column(name))

                );

            } else {

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

                    sqlbuilder.eq(

                        sqlbuilder.column(name),

                        sqlbuilder.parameter(name).value(value)

                    )

                );

            }

        }

        sqlbuilder.select().limit(1);

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

        PreparedStatement st = null;

        ResultSet rs = null;

        try {

            st = conn.prepareStatement(sql);

            sqlbuilder.setParameters(st);

            rs = JDBCUtils.executeQuery(st, sql);

            if (!rs.next()) {

                return null;

            }

            FeatureProvider data = this.helper.createFeature(featureType);

            this.helper.fetchFeature(data, rs, columns.toArray(new FeatureAttributeDescriptor[columns.size()]));

            return data;

        } catch (SQLException ex) {

            throw new JDBCSQLException(ex);

        } finally {

            JDBCUtils.closeQuietly(st);

            JDBCUtils.closeQuietly(rs);

        }

    }

}