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 java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

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

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

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

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

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

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

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

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;

public class TableIsEmptyOperation extends AbstractConnectionOperation {

    private final TableReference table;

    private final String baseFilter;

    private final String filter;

    private final FeatureType featureType;

    public TableIsEmptyOperation(

            JDBCHelper helper

        ) {

        this(helper, null, null, null, null);

    }

    public TableIsEmptyOperation(

            JDBCHelper helper,

            FeatureType featureType,

            TableReference table,

            String baseFilter,

            String filter

        ) {

        super(helper);

        this.featureType = featureType;

        this.table = table;

        this.baseFilter = baseFilter;

        this.filter = filter;

    }

    @Override

    public final Object perform(Connection conn) throws DataException {

        return this.tableIsEmpty(conn);

    }

    public String getSQL() {

        JDBCSQLBuilderBase sqlbuilder = this.createSQLBuilder();

        ExpressionBuilder expbuilder = sqlbuilder.expression();

        sqlbuilder.select().column().all();

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

        }

        if (!StringUtils.isEmpty(filter)) {

            // El and() hace un set() si no hay un filtro previo

            sqlbuilder.select().where().and(expbuilder.toValue(filter));

        }

        sqlbuilder.select().limit(1);

        this.helper.replaceForeingValueFunction(sqlbuilder, featureType);

        sqlbuilder.setProperties(

                ExpressionBuilder.Variable.class, 

                PROP_TABLE, table

        );

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

        return sql;

    }

    public boolean tableIsEmpty(Connection conn) throws DataException {

        String sql = this.getSQL();

        Statement st = null;

        ResultSet rs = null;

        try {

            st = conn.createStatement();

            rs = JDBCUtils.executeQuery(st, sql);

            return !rs.next();

        } catch (SQLException ex) {

            throw new JDBCSQLException(ex);

        } finally {

            JDBCUtils.closeQuietly(st);

            JDBCUtils.closeQuietly(rs);

        }

    }

}