Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2020 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

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

import java.sql.PreparedStatement;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.Arrays;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import org.apache.commons.collections.CollectionUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionBuilder.Parameter;

import org.gvsig.expressionevaluator.ExpressionBuilder.Variable;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.SQLBuilder;

import static org.gvsig.fmap.dal.SQLBuilder.PROP_FEATURE_TYPE;

import static org.gvsig.fmap.dal.SQLBuilder.PROP_TABLE;

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.store.jdbc.JDBCStoreParameters;

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

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

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

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 org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.util.Bitmask;

import org.gvsig.tools.util.Invocable;

@SuppressWarnings("UseSpecificCatch")

public class PerformChangesOperation extends AbstractConnectionWritableOperation {

    protected TableReference table;

    protected FeatureType featureType;

    protected FeatureType featureTypeSource;

    protected FeatureType featureTypeTarget;

    protected Iterator<FeatureReferenceProviderServices> deleteds;

    protected Iterator<FeatureProvider> updateds;

    protected Iterator<FeatureProvider> inserteds;

    protected boolean typeChanged = false;

    protected final FeatureStoreProviderServices storeServices;

    public PerformChangesOperation(JDBCHelper helper) {

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

    }

    public PerformChangesOperation(JDBCHelper helper,

            TableReference table,

            FeatureType featureType,

            Iterator<FeatureReferenceProviderServices> deleteds,

            Iterator<FeatureProvider> inserteds,

            Iterator<FeatureProvider> updateds,

            Iterator<FeatureTypeChanged> featureTypesChanged,

            FeatureStoreProviderServices storeServices) {

        super(helper);

        this.deleteds = deleteds;

        this.inserteds = inserteds;

        this.updateds = updateds;

        this.table = table;

        this.featureType = featureType;

        if (featureTypesChanged.hasNext()) {

            FeatureTypeChanged item = featureTypesChanged.next();

            this.featureTypeSource = item.getSource();

            this.featureTypeTarget = item.getTarget();

            typeChanged = true;

        } else {

            this.featureTypeSource = null;

            this.featureTypeTarget = null;

            typeChanged = false;

        }

        this.storeServices = storeServices;

    }

    public boolean isTypeChanged() {

        return typeChanged;

    }

    @Override

    public Object perform(JDBCConnection conn) throws DataException {

        if (typeChanged) {

            this.performUpdateTable(conn);

        }

        if (inserteds.hasNext()) {

            performInserts(conn);

        }

        if (updateds.hasNext()) {

            performUpdates(conn);

        }

        if (deleteds.hasNext()) {

            performDeletes(conn);

        }

        return true;

    }

    public String getDeleteSQL() {

        JDBCSQLBuilderBase sqlbuilder = createSQLBuilder();

        return this.getDeleteSQL(sqlbuilder);

    }

    public String getDeleteSQL(JDBCSQLBuilderBase sqlbuilder) {

        ExpressionBuilder expbuilder = sqlbuilder.expression();

        sqlbuilder.delete().table()

                .database(this.table.getDatabase())

                .schema(this.table.getSchema())

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

        for (FeatureAttributeDescriptor attr : this.featureType) {

            if (attr.isPrimaryKey()) {

                sqlbuilder.delete().where().and(

                        expbuilder.eq(

                                expbuilder.column(attr.getName()),

                                expbuilder.parameter(attr.getName()).as_variable()

                        )

                );

            }

        }

        if (!sqlbuilder.delete().has_where() ) {

            throw new RuntimeException("Operation requires missing pk");

        }

        sqlbuilder.setProperties(

                Variable.class, 

                PROP_TABLE, table

        );

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

        return sql;

    }

    public void performDeletes(JDBCConnection conn) throws DataException {

        JDBCSQLBuilderBase sqlbuilder = createSQLBuilder();

        String sql = getDeleteSQL(sqlbuilder);

        perform_batchmode(conn, this.deleteds, sqlbuilder, sql, new Invocable() {

            @Override

            public Object call(Object... args) {

                JDBCSQLBuilderBase sqlbuilder = (JDBCSQLBuilderBase) args[0];

                PreparedStatement preparedStatement = (PreparedStatement) args[1];

                FeatureReference reference = (FeatureReference) args[2];

                Disposable theParametersDisposable = sqlbuilder.setParameters(preparedStatement, reference);

                return theParametersDisposable;

            }

        });

    }

    public String getInsertSQL() {

        JDBCSQLBuilderBase sqlbuilder = createSQLBuilder();

        return this.getInsertSQL(sqlbuilder);

    }

    public String getInsertSQL(JDBCSQLBuilderBase sqlbuilder) {

        GeometryExpressionBuilder expbuilder = sqlbuilder.expression();

        sqlbuilder.insert().table()

                .database(this.table.getDatabase())

                .schema(this.table.getSchema())

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

        for (FeatureAttributeDescriptor attr : this.featureType) {

            // Cuando insertamos registros hay que permitir meter un valor

            // en la claves automaticas. Es responsable de quien los inserta,

            // en caso de que no meta nulos, que se asegure que no hay valores

            // duplicados, ya que que de haberlos fallara el insert.

            if( /*attr.isAutomatic() ||*/ attr.isComputed() ) {

                continue;

            }

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

                sqlbuilder.insert().column().name(attr.getName()).with_value(

                    expbuilder.parameter(attr.getName()).as_variable()

                        .srs(

                            expbuilder.parameter().value(

                                attr.getSRS()).as_constant()

                        )

                );

            } else {

                sqlbuilder.insert().column().name(attr.getName()).with_value(

                        expbuilder.parameter(attr.getName())

                );

            }

        }

        sqlbuilder.setProperties(

                Variable.class, 

                PROP_FEATURE_TYPE, featureType,

                PROP_TABLE, table

        );

        sqlbuilder.setProperties(

                Parameter.class, 

                PROP_FEATURE_TYPE, featureType,

                PROP_TABLE, table

        );

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

        return sql;

    }

    public void performInserts(JDBCConnection conn) throws DataException {

        JDBCSQLBuilderBase sqlbuilder = createSQLBuilder();

        String sql = getInsertSQL(sqlbuilder);

        perform_batchmode(conn, this.inserteds, sqlbuilder, sql, new Invocable() {

            @Override

            public Object call(Object... args) {

                JDBCSQLBuilderBase sqlbuilder = (JDBCSQLBuilderBase) args[0];

                PreparedStatement preparedStatement = (PreparedStatement) args[1];

                FeatureProvider feature = (FeatureProvider) args[2];

                Disposable theParametersDisposable = sqlbuilder.setParameters(preparedStatement, feature);

                return theParametersDisposable;

            }

        });

    }

    public String getUpdateSQL() {

        JDBCSQLBuilderBase sqlbuilder = createSQLBuilder();

        return this.getUpdateSQL(sqlbuilder);

    }

    public String getUpdateSQL(JDBCSQLBuilderBase sqlbuilder) {

        if(!this.featureType.hasPrimaryKey()) {

            throw new RuntimeException("Operation requires missing pk");

        }

        GeometryExpressionBuilder expbuilder = sqlbuilder.expression();

        sqlbuilder.update().table()

                .database(this.table.getDatabase())

                .schema(this.table.getSchema())

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

        for (FeatureAttributeDescriptor attr : this.featureType) {

            if (attr.isPrimaryKey()) {

                sqlbuilder.update().where().and(

                        expbuilder.eq(

                                expbuilder.column(attr.getName()),

                                expbuilder.parameter(attr.getName()).as_variable()

                        )

                );

                continue;

            } 

            if ( attr.isAutomatic() || attr.isReadOnly() || attr.isComputed() ) {

                continue;

            }

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

                if (attr.getSRS()==null) {

                    throw new RuntimeException("Geometries with null srs are not valid. SRS is required in "+this.table.toString()+"in the field:"+attr.getName());

                }

                sqlbuilder.update().column().name(attr.getName()).with_value(

                    expbuilder.parameter(attr.getName()).as_geometry_variable().srs(

                        expbuilder.parameter().value(attr.getSRS()).as_constant()

                    )

                );

            } else {

                sqlbuilder.update().column().name(attr.getName()).with_value(

                    expbuilder.parameter(attr.getName()).as_variable()

                );

            }

        }

        if (!sqlbuilder.update().has_where() ) {

            throw new RuntimeException("Operation requires missing pk");

        }

        sqlbuilder.setProperties(

                Variable.class, 

                PROP_FEATURE_TYPE, this.featureType,

                PROP_TABLE, table

        );

        sqlbuilder.setProperties(

                Parameter.class, 

                PROP_FEATURE_TYPE, featureType,

                PROP_TABLE, table

        );

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

        return sql;

    }

    public void performUpdates(JDBCConnection conn) throws DataException {

        JDBCSQLBuilderBase sqlbuilder = createSQLBuilder();

        String sql = getUpdateSQL(sqlbuilder);

        perform_batchmode(conn, this.updateds, sqlbuilder, sql, new Invocable() {

            @Override

            public Object call(Object... args) {

                JDBCSQLBuilderBase sqlbuilder = (JDBCSQLBuilderBase) args[0];

                PreparedStatement preparedStatement = (PreparedStatement) args[1];

                FeatureProvider feature = (FeatureProvider) args[2];

                Disposable theParametersDisposable = sqlbuilder.setParameters(preparedStatement, feature);

                return theParametersDisposable;

            }

        });

    }

    private void perform_batchmode(JDBCConnection conn, Iterator elements, JDBCSQLBuilderBase sqlbuilder, String sql, Invocable fillPreparedStatement) throws DataException {       

        PreparedStatement preparedStatement;

        Disposable[] disposableParameters;

        int batchSize = this.helper.getConnectionParameters().getBatchSize();

        if( batchSize==0 ) {

            try {

                preparedStatement = conn.prepareStatement(sql);

                while (elements.hasNext()) {

                    Object element = elements.next();

                    Disposable theParametersDisposable = (Disposable) fillPreparedStatement.call(sqlbuilder,preparedStatement, element );

                    JDBCUtils.execute(preparedStatement, sql);

                    DisposeUtils.disposeQuietly(theParametersDisposable);

                }                

            } catch (Exception ex) {

                throw new JDBCExecuteSQLException(sql + " ("+Objects.toString(elements)+")",ex);

            }

        } else {

            try {

                preparedStatement = conn.prepareStatement(sql);

                if( batchSize<1 ) {

                    batchSize = 200;

                }

                int batchCount = 0;

                disposableParameters = new Disposable[batchSize];

                while (elements.hasNext()) {

                    Object element = elements.next();

                    Disposable theParametersDisposable = (Disposable) fillPreparedStatement.call(sqlbuilder,preparedStatement, element );

                    JDBCUtils.addBatch(preparedStatement,sql);

                    disposableParameters[batchCount++] = theParametersDisposable;

                    if( batchCount >= batchSize || (!elements.hasNext() && batchCount>0) ) {

                        int[] status = JDBCUtils.executeBatch(preparedStatement,sql);

                        preparedStatement.clearParameters();

                        preparedStatement.clearBatch();

                        for (int i = 0; i < batchCount && i < disposableParameters.length; i++) {

                            DisposeUtils.dispose(disposableParameters[i]);

                            disposableParameters[i] = null;

                        }

                        batchCount = 0;

                        for (int n : status) {

                            if( n<=Statement.EXECUTE_FAILED ) { //-3

                                throw new RuntimeException("Can't process element (n="+n+").");

                            }

                        }                

                    }

                }

            } catch (Exception ex) {

                throw new JDBCExecuteSQLException(sql,ex);

            }

        }

    }

    protected FeatureType getCurrentFeatureTypeDB(){

        if(this.storeServices == null){

            return this.featureTypeSource;

        }

        try{

            JDBCStoreParameters params = (JDBCStoreParameters) this.storeServices.getFeatureStore().getParameters();

            EditableFeatureType type = this.storeServices.createFeatureType(this.storeServices.getName());

            FetchFeatureTypeOperation fetchFeatureType = 

                 this.helper.getOperations().createFetchFeatureType(

                    type,

                    this.table,

                    params.getPkFields()==null?null:Arrays.asList(params.getPkFields()),

                    params.getDefaultGeometryField(),

                    params.getCRS(),

                    params.getGeometryType(),

                    params.getGeometrySubtype()

                );

            fetchFeatureType.perform(this.getConnection());

            return type;

        } catch(Throwable t){

            LOGGER.warn("Can't get current feature type from database of table = "+Objects.toString(this.table), t);

            return this.featureTypeSource;

        }

    }

    public List<String> getUpdateTableSQLs() {

        FeatureType currentFeatureTypeDB = getCurrentFeatureTypeDB();

        Map<String, Bitmask> changes = getUpdateTableChanges(currentFeatureTypeDB);

        List<String> sqls = getUpdateTableSQLs(currentFeatureTypeDB, changes);

        return sqls;

    }

    public List<String> getUpdateTableSQLs(FeatureType currentFeatureTypeDB, Map<String, Bitmask> changes) {

        JDBCSQLBuilderBase sqlbuilder = createSQLBuilder();

        SQLBuilder.AlterTableBuilder alter_table = sqlbuilder.alter_table();

        alter_table.setProperty(PROP_FEATURE_TYPE, featureTypeTarget);

        alter_table.table()

                .database(this.table.getDatabase())

                .schema(this.table.getSchema())

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

//        // Primero comprobamos si hay que eliminar la primary-key o algun indice

//        for (FeatureAttributeDescriptor attrOrgiginal : currentFeatureTypeDB) {

//            if( attrOrgiginal.isComputed() ) {

//                continue;

//            }

//            FeatureAttributeDescriptor attrTarget = featureTypeTarget.getAttributeDescriptor(

//                    attrOrgiginal.getName()

//            );

//            if (attrTarget == null) {

//                continue;

//            }

//            if( attrOrgiginal.isPrimaryKey() && !attrTarget.isPrimaryKey() ) {

//                sqlbuilder.alter_table().drop_primary_key(attrTarget.getName());

//            }

//        }

        // Comprobamos si hay que eliminar o modificar alguna columna existente

        for (FeatureAttributeDescriptor attrOriginal : currentFeatureTypeDB) {

            if( attrOriginal.isComputed() ) {

                continue;

            }

            FeatureAttributeDescriptor attrTarget = featureTypeTarget.getAttributeDescriptor(

                    attrOriginal.getName()

            );

            if (attrTarget == null) {

                sqlbuilder.alter_table().drop_column(attrOriginal.getName());

            } else {

                Bitmask changesAttr = changes.get(attrOriginal.getName());

                if( !changesAttr.isEmpty() ) {

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

                        sqlbuilder.alter_table().alter_geometry_column(

                                changesAttr,

                                attrTarget.getName(),

                                attrTarget.getGeomType().getType(),

                                attrTarget.getGeomType().getSubType(),

                                attrTarget.getSRS(),

                                attrTarget.isIndexed(),

                                attrTarget.allowNull()

                        );

                    } else {

                        Object defaultValue = attrTarget.getDefaultValue();

                        if( defaultValue instanceof CharSequence ) {

                            if( ExpressionUtils.isDynamicText(defaultValue.toString())) {

                                defaultValue = null;

                            }

                        }

                        sqlbuilder.alter_table().alter_column(    

                                changesAttr,

                                attrTarget.getName(),

                                attrTarget.getType(),

                                attrTarget.getSize(),

                                attrTarget.getPrecision(),

                                attrTarget.getScale(),

                                attrTarget.isPrimaryKey(),

                                attrTarget.isIndexed(),

                                attrTarget.allowNull(),

                                attrTarget.isAutomatic(),

                                defaultValue,

                                attrTarget.allowIndexDuplicateds()

                        );

                    }

                }

            }

        }

        // Por ultimo comprobamos si hay que anadir alguna columna nueva.

        for (FeatureAttributeDescriptor attrTarget : featureTypeTarget) {

            if( attrTarget.isComputed() ) {

                continue;

            }

            FeatureAttributeDescriptor attrOriginal = currentFeatureTypeDB.getAttributeDescriptor(

                    attrTarget.getName()

            );

            if (attrOriginal == null) {

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

                    sqlbuilder.alter_table().add_geometry_column(

                            attrTarget.getName(),

                            attrTarget.getGeomType().getType(),

                            attrTarget.getGeomType().getSubType(),

                            attrTarget.getSRS(),

                            attrTarget.isIndexed(),

                            attrTarget.allowNull()

                    );

                } else {

                    Object defaultValue = attrTarget.getDefaultValue();

                    if( defaultValue instanceof CharSequence ) {

                        if( ExpressionUtils.isDynamicText(defaultValue.toString())) {

                            defaultValue = null;

                        }

                    }

                    sqlbuilder.alter_table().add_column(

                            attrTarget.getName(),

                            attrTarget.getType(),

                            attrTarget.getSize(),

                            attrTarget.getPrecision(),

                            attrTarget.getScale(),

                            attrTarget.isPrimaryKey(),

                            attrTarget.isIndexed(),

                            attrTarget.allowNull(),

                            attrTarget.isAutomatic(),

                            defaultValue,

                            attrTarget.allowIndexDuplicateds()

                    );

                }

            }

        }

        sqlbuilder.setProperties(

                Variable.class, 

                PROP_TABLE, table

        );

        List<String> sqls = sqlbuilder.alter_table().toStrings();

//        sqls.addAll(buildCreateIndexSQL());

        return sqls;

    }

    public Map<String, Bitmask> getUpdateTableChanges(FeatureType currentFeatureTypeDB) {

        Map<String, Bitmask> changes = new HashMap<>();

        // Comprobamos si hay que eliminar o modificar alguna columna existente

        for (FeatureAttributeDescriptor attrOriginal : currentFeatureTypeDB) {

            if( attrOriginal.isComputed() ) {

                continue;

            }

            FeatureAttributeDescriptor attrTarget = featureTypeTarget.getAttributeDescriptor(

                    attrOriginal.getName()

            );

            if (attrTarget == null) {

                Bitmask changesAttr = Bitmask.createBitmask(0);

                changesAttr.setBit(SQLBuilder.AlterTableBuilder.ALTER_COLUMN_DROP_COLUMN);

                changes.put(attrOriginal.getName(), changesAttr);

            } else {

                Bitmask changesAttr = this.getAlterTableChanges(attrOriginal, attrTarget);

                changes.put(attrOriginal.getName(), changesAttr);

            }

        }

        // Por ultimo comprobamos si hay que anadir alguna columna nueva.

        for (FeatureAttributeDescriptor attrTarget : featureTypeTarget) {

            if( attrTarget.isComputed() ) {

                continue;

            }

            FeatureAttributeDescriptor attrOriginal = currentFeatureTypeDB.getAttributeDescriptor(

                    attrTarget.getName()

            );

            if (attrOriginal == null) {

                Bitmask changesAttr = Bitmask.createBitmask(0);

                changesAttr.setBit(SQLBuilder.AlterTableBuilder.ALTER_COLUMN_ADD_COLUMN);

                changes.put(attrTarget.getName(), changesAttr);

            }

        }

        return changes;

    }

    protected Bitmask getAlterTableChanges(FeatureAttributeDescriptor src, FeatureAttributeDescriptor target) {

        Bitmask changes = Bitmask.createBitmask(0);

        if( src.getType() != target.getType() ) {

            changes.setBit(SQLBuilder.AlterTableBuilder.ALTER_COLUMN_SET_DATA_TYPE);

        }

        if( src.getPrecision() != target.getPrecision() ) {

            changes.setBit(SQLBuilder.AlterTableBuilder.ALTER_COLUMN_SET_DATA_TYPE);

        }

        if( src.getScale() != target.getScale() ) {

            changes.setBit(SQLBuilder.AlterTableBuilder.ALTER_COLUMN_SET_DATA_TYPE);

        }

        if( src.getSize() != target.getSize() ) {

            changes.setBit(SQLBuilder.AlterTableBuilder.ALTER_COLUMN_SET_DATA_TYPE);

        }

        if( src.isPrimaryKey() != target.isPrimaryKey() ) {

            if( target.isPrimaryKey() ) {

                changes.setBit(SQLBuilder.AlterTableBuilder.ALTER_COLUMN_ADD_PRIMARY_KEY);

            } else {

                changes.setBit(SQLBuilder.AlterTableBuilder.ALTER_COLUMN_DROP_PRIMARY_KEY);

            }

        }        

        if( src.isIndexed()!= target.isIndexed()) {

            if( target.isIndexed()) {

                changes.setBit(SQLBuilder.AlterTableBuilder.ALTER_COLUMN_CREATE_INDEX);

            } else {

                changes.setBit(SQLBuilder.AlterTableBuilder.ALTER_COLUMN_DROP_INDEX);

            }

        }        

        if( src.isAutomatic() != target.isAutomatic() ) {

            changes.setBit(SQLBuilder.AlterTableBuilder.ALTER_COLUMN_SET_DATA_TYPE);

        }

        if( src.allowNull() != target.allowNull() ) {

            changes.setBit(SQLBuilder.AlterTableBuilder.ALTER_COLUMN_SET_NULL);

        }

        if( src.getDefaultValue() != target.getDefaultValue() ) {

            changes.setBit(SQLBuilder.AlterTableBuilder.ALTER_COLUMN_SET_DEFAULT);

        }

        return changes;

    }

//    protected List<String> buildCreateIndexSQL() {

//        ArrayList<String> sqls = new ArrayList<>();

//        

//        for (FeatureAttributeDescriptor attrTarget : featureTypeTarget) {

//            boolean createIndex;

//            boolean dropIndex;

//            FeatureAttributeDescriptor attrOriginal = featureTypeSource.getAttributeDescriptor(attrTarget.getName());

//            if( attrOriginal != null ) {

//                 createIndex = (attrTarget.isIndexed() && !attrOriginal.isIndexed());

//                 dropIndex = (!attrTarget.isIndexed() && attrOriginal.isIndexed());

//            } else {

//                createIndex = attrTarget.isIndexed();

//                dropIndex = false;

//            }

//            if( createIndex ) {

//                JDBCSQLBuilderBase sqlbuilder = createSQLBuilder();

//                if( attrTarget.getType()==DataTypes.GEOMETRY ) {

//                    sqlbuilder.create_index().spatial();

//                }

//                sqlbuilder.create_index().if_not_exist();

//                sqlbuilder.create_index().name(table.getTable(), attrTarget.getName());

//                sqlbuilder.create_index().column(attrTarget.getName());

//                sqlbuilder.create_index().table()

//                    .database(this.table.getDatabase())

//                    .schema(this.table.getSchema())

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

//                sqlbuilder.setProperties(

//                        Variable.class, 

//                        PROP_TABLE, table

//                );

//                sqls.addAll(sqlbuilder.create_index().toStrings());

//            } else if( dropIndex ) {

//                JDBCSQLBuilderBase sqlbuilder = createSQLBuilder();

//                sqlbuilder.drop_index().if_not_exist();

//                sqlbuilder.drop_index().name( table.getTable(), attrTarget.getName());

//            }

//        }

//        return sqls;

//    }

    public void performUpdateTable(JDBCConnection conn) throws DataException {

        List<String> sqls = this.getUpdateTableSQLs();

        if( !CollectionUtils.isEmpty(sqls) ) {

            Statement st = null;

            String currentsql = null;

            try {

                st = conn.createStatement();

                for (String sql : sqls) {

                    currentsql = sql;

                    if( !StringUtils.isBlank(sql) ) {

                        JDBCUtils.execute(st, sql);

                    }

                }

            } catch (SQLException e) {

                throw new JDBCSQLException(e,currentsql);

            } finally {

                JDBCUtils.closeQuietly(st);

            }

        }

    }

}