Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 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.export.jdbc.service;

import java.text.MessageFormat;

import java.util.Objects;

import org.cresques.cts.ICoordTrans;

import org.gvsig.export.ExportAttributes;

import org.gvsig.export.ExportException;

import org.gvsig.export.ExportLocator;

import org.gvsig.export.spi.AbstractExportService;

import org.gvsig.export.spi.ExportService;

import org.gvsig.export.spi.ExportServiceFactory;

import org.gvsig.export.spi.ExportServiceManager;

import org.gvsig.export.spi.ExportServiceManager.FixGeometryStatus;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

import org.gvsig.fmap.dal.DataTransaction;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.NewDataStoreParameters;

import org.gvsig.fmap.dal.OpenDataStoreParameters;

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryCoercionContext;

import org.gvsig.tools.dispose.DisposableIterator;

/**

 * @author gvSIG Team

 * @version $Id$

 *

 */

public class ExportJDBCService

        extends AbstractExportService

        implements ExportService {

    private FeatureType targetFeatureType;

    protected ExportJDBCService(ExportServiceFactory factory, ExportJDBCParameters parameters) {

        super(factory, parameters);

    }

    @Override

    public ExportJDBCParameters getParameters() {

        return (ExportJDBCParameters) super.getParameters();

    }

    @Override

    protected JDBCServerExplorer createServerExplorer() throws ExportException {

        try {

            DataManager dataManager = DALLocator.getDataManager();

            JDBCServerExplorer explorer = (JDBCServerExplorer) dataManager.openServerExplorer(

                    this.getParameters().getExplorerParameters().getExplorerName(),

                    this.getParameters().getExplorerParameters()

            );

            return explorer;

        } catch (Exception e) {

            throw new ExportException(e);

        }

    }

    @Override

    protected NewDataStoreParameters createTargetNewStoreParameters() throws ExportException {

        try {

            FeatureType targetTempFeatureType;

            EditableFeatureType targetEditableFeatureType;

            JDBCServerExplorer explorer = this.createServerExplorer();

            DataManager manager = DALLocator.getDataManager();

            FeatureStoreProviderFactory factory = (FeatureStoreProviderFactory) manager.getStoreProviderFactory(explorer.getStoreName());

            boolean preferNotToUseNonNullRestrictions = factory.preferNotToUseNonNullRestrictions();

            ExportAttributes exportAttributes = getParameters().getExportAttributes();

            targetTempFeatureType = exportAttributes.getTargetFeatureType().getCopy();

            targetEditableFeatureType = targetTempFeatureType.getEditable();

            targetEditableFeatureType.setHasOID(false);

            // Remove inherited primary keys from the data source and remove NotNull

            // restrictions if proceed.

            for (int i = 0; i < targetEditableFeatureType.size(); i++) {

                EditableFeatureAttributeDescriptor eAttr = (EditableFeatureAttributeDescriptor) targetEditableFeatureType.get(i);

                if( eAttr.isPrimaryKey() && factory.allowEditableFeatureType()!=DataStoreProviderFactory.NO) {

                    eAttr.setIsPrimaryKey(false);

                    eAttr.setAllowNull(false);

                } else {

                    if (preferNotToUseNonNullRestrictions) {

                        eAttr.setAllowNull(true);

                    }

                }

            }

            String pkname = getParameters().getPrimaryKey();

            if (pkname != null) { 

                // pkname it's not part of exportattributes list.

                pkname = this.getParameters().getExportAttributes().getTargetName(pkname);

                EditableFeatureAttributeDescriptor pk = (EditableFeatureAttributeDescriptor) targetEditableFeatureType.get(pkname);

                if (pk == null) {

                    pkname = getParameters().getExportAttributes().getNamesTranslator().getSuggestion(pkname);

                    pk = targetEditableFeatureType.add(pkname, DataTypes.LONG);

                    pk.setIsPrimaryKey(true);

                    pk.setIsAutomatic(true);

                    pk.setIsReadOnly(true);

                } else {

                    pk.setIsPrimaryKey(true);

//                    pk.setIsReadOnly(true);

                }

            }

            EditableFeatureAttributeDescriptor attrdescriptor = (EditableFeatureAttributeDescriptor) targetEditableFeatureType.getDefaultGeometryAttribute();

            if (attrdescriptor != null && this.getParameters().getCreateIndexInGeometryRow()) {

                attrdescriptor.setIsIndexed(true);

            }

            // ======================================================

            // Reprojection: set SRS of geometry field to target SRS

            if (attrdescriptor != null) {

                attrdescriptor.setSRS(this.getParameters().getTargetProjection());

                attrdescriptor.setGeometryType(this.getParameters().getTargetGeometryType());

            }

            // ======================================

            // Remove index to improve performance

            this.targetFeatureType = targetEditableFeatureType.getNotEditableCopy();

            if( factory.allowEditableFeatureType()!=DataStoreProviderFactory.NO) {

                for (int i = 0; i < targetEditableFeatureType.size(); i++) {

                    EditableFeatureAttributeDescriptor x = (EditableFeatureAttributeDescriptor) targetEditableFeatureType.get(i);

                    //x.setIsPrimaryKey(false);

                    x.setIsIndexed(false);

                }

            }

            // ======================================

            JDBCNewStoreParameters createTableParams = (JDBCNewStoreParameters) explorer.getAddParameters();

            createTableParams.setSelectRole(this.getParameters().getSelectRole());

            createTableParams.setInsertRole(this.getParameters().getInsertRole());

            createTableParams.setUpdateRole(this.getParameters().getUpdateRole());

            createTableParams.setDeleteRole(this.getParameters().getDeleteRole());

            createTableParams.setTruncateRole(this.getParameters().getTruncateRole());

            createTableParams.setReferenceRole(this.getParameters().getReferenceRole());

            createTableParams.setTriggerRole(this.getParameters().getTriggerRole());

            createTableParams.setAllRole(this.getParameters().getAllRole());

            createTableParams.setSchema(this.getParameters().getSchema());

            createTableParams.setPostCreatingStatement(this.getParameters().getPostCreatingStatement());

            createTableParams.setDefaultFeatureType(targetEditableFeatureType);

            createTableParams.setTable(this.getParameters().getTableName());

            return createTableParams;

        } catch (Exception ex) {

            throw new ExportException(ex);

        }

    }

    @Override

    public OpenDataStoreParameters createTargetOpenStoreParameters() throws ExportException {

        try {

            DataManager dataManager = DALLocator.getDataManager();

            JDBCServerExplorer explorer = this.createServerExplorer();

            JDBCStoreParameters openStoreParameters = (JDBCStoreParameters) explorer.getOpenParameters();

            openStoreParameters.setSchema(this.getParameters().getSchema());

            openStoreParameters.setTable(this.getParameters().getTableName());

            openStoreParameters.setCRS(this.getParameters().getTargetProjection());

            openStoreParameters.setDefaultGeometryField(

                    this.getParameters().getTargetFeatureType().getDefaultGeometryAttributeName()

            );

            return openStoreParameters;

        } catch (DataException ex) {

            throw new ExportException(ex);

        }

    }

    private int getGeometryColumnCount(FeatureType featureType) {

        int count = 0;

        for (int i = 0; i < featureType.size(); i++) {

            if (featureType.getAttributeDescriptor(i).getType() == DataTypes.GEOMETRY) {

                count++;

            }

        }

        return count;

    }

    @Override

    public void export(FeatureSet featureSet) throws ExportException {

        Geometry.ValidationStatus geometryCheck;

        DisposableIterator it = null;

        EditableFeature targetFeature = null;

        FeatureStore target = null;

        Feature feature = null;

        DataManager dataManager = DALLocator.getDataManager();

        DataTransaction trans = dataManager.createTransaction();

        try {

            ExportServiceManager serviceManager = ExportLocator.getServiceManager();

            // ======================================

            // Reprojection

            ICoordTrans coord_trans = this.getParameters().getTransformationToUse();

            // ============================================

            JDBCServerExplorer explorer = this.createServerExplorer();

            trans.add(explorer);

            if (this.getParameters().canCreatetable()) {

                LOG.debug("Creating table");

                getTaskStatus().message("Creating table");

                NewDataStoreParameters targetNewStoreParameters = this.createTargetNewStoreParameters();

                explorer.add(

                        targetNewStoreParameters.getDataStoreName(),

                        targetNewStoreParameters,

                        true

                );

                //We collect the name of the table of targetNewStoreParameters 

                //because the provider has been able to make changes to it

                this.getParameters().setTableName(((JDBCNewStoreParameters)targetNewStoreParameters).getTable());

            }

            JDBCStoreParameters openParams = (JDBCStoreParameters) this.createTargetOpenStoreParameters();

            try {

                 LOG.info("Start export "+Objects.toString(openParams));

            } catch (Throwable t){

                 LOG.info("Start export");              

            }

            target = (FeatureStore) explorer.open(openParams);

            FeatureType theTargetFeatureType = target.getDefaultFeatureType();

            FeatureType theSourceFeatureType = featureSet.getDefaultFeatureType();

            if (!this.getParameters().canCreatetable() && this.getParameters().isDeleteRows()) {

                Expression filter = this.getParameters().getDeleteRowsFilter();

                if(ExpressionUtils.isPhraseEmpty(filter)){

                    filter = ExpressionUtils.createExpression("1=1");

                }

                target.edit(FeatureStore.MODE_PASS_THROUGH);

                target.delete(filter);

                target.finishEditing();

            }

            target.edit(FeatureStore.MODE_APPEND);

            long featureCount = 1;

            getTaskStatus().setRangeOfValues(1, featureSet.getSize());

            int targetGeometryIndex = -1;

            int sourceGeometryIndex = -1;

            if (getGeometryColumnCount(theSourceFeatureType) == 1

                    && getGeometryColumnCount(theTargetFeatureType) == 1) {

                // Si solo hay una columna de geometria asignaremos las geometrias

                // independientemente de como se llamen los campos.

                targetGeometryIndex = theTargetFeatureType.getDefaultGeometryAttributeIndex();

                sourceGeometryIndex = theSourceFeatureType.getDefaultGeometryAttributeIndex();

            } else {

                FeatureAttributeDescriptor attr = theSourceFeatureType.getDefaultGeometryAttribute();

                if (attr!=null && theTargetFeatureType.getAttributeDescriptor(attr.getName())!=null) {

                    sourceGeometryIndex = attr.getIndex();

                    targetGeometryIndex = theTargetFeatureType.getAttributeDescriptor(attr.getName()).getIndex();

                }

            }

            if(targetGeometryIndex != -1){

                GeometryCoercionContext coercionContext = (GeometryCoercionContext) theTargetFeatureType.getAttributeDescriptor(targetGeometryIndex).getCoercionContext();

                if(coercionContext!=null){

                    coercionContext.setMode(GeometryCoercionContext.MODE_ONERROR_NULL);

                }

            }

            LOG.debug("Inserting rows");

            getTaskStatus().message("Inserting rows");

            it = featureSet.fastIterator();

            while (it.hasNext()) {

                feature = (Feature) it.next();

                targetFeature = target.createNewFeature(theTargetFeatureType, true);

                targetFeature.copyFrom(feature);

                for (int i = 0; i < theSourceFeatureType.size(); i++) {

                    if (i == sourceGeometryIndex) {

                        // Es facil que los campos geometria no se llamen igual, asi que

                        // el campo geometria lo asignamos a capon.

                        // Esto puede ocasionar problemas cuando la tabla destino no tenga

                        // geometria o tenga mas de una.

                        targetFeature.set(targetGeometryIndex, feature.get(sourceGeometryIndex));

                    } else {

                        FeatureAttributeDescriptor sourceField = theSourceFeatureType.getAttributeDescriptor(i);

//                        String name = getTranslatedIdentifier(x.getName());

                        if (!this.getParameters().getExportAttributes().getExportAttribute(sourceField.getName()).isExported()) {

                            continue;

                        }

                        String targetField = this.getParameters().getExportAttributes().getTargetName(sourceField.getName());

                        int targetAttributeIndex = theTargetFeatureType.getIndex(targetField);

                        if (targetAttributeIndex < 0 ) {

                            continue;

                            //throw new RuntimeException("Can't locate column '" + x.getName() + "' in the target table.");

                        }

                        if (theTargetFeatureType.getAttributeDescriptor(targetField).isReadOnly() ) {

                            continue;

                        }

                        targetFeature.set(targetAttributeIndex, feature.get(sourceField.getName()));

                    }

                }

                if (targetGeometryIndex!=-1) {

                    Geometry geometry = targetFeature.getGeometry(targetGeometryIndex);

                    FixGeometryStatus check = serviceManager.fixGeometry(getParameters(), coord_trans, geometry);

                    switch (check.getState()) {

                        case FixGeometryStatus.STATE_OK:

                            targetFeature.setDefaultGeometry(check.getGeometry());

                            break;

                        case FixGeometryStatus.STATE_SKIP:

                            continue;

                        case FixGeometryStatus.STATE_ABORT:

                            throw new InvalidGeometryException(targetFeature, check.getMessage());

                    }

                }

                target.insert(targetFeature);

                this.getTaskStatus().incrementCurrentValue();

                if (this.getTaskStatus().isCancellationRequested()) {

                    return;

                }

                featureCount++;

            }

            String msgRowCount = MessageFormat.format(" ({0,number, #,###} rows)", featureCount);

            targetFeature = null;

            getTaskStatus().setIndeterminate();

            LOG.debug("Finish editing" + msgRowCount);

            if (featureCount > 50000) {

                getTaskStatus().message("Finishing insertion of records, may take a while" + msgRowCount);

            } else {

                getTaskStatus().message("Finishing insertion of records" + msgRowCount);

            }

            target.finishEditing();

            if (this.getParameters().canCreatetable() && ((FeatureStoreProviderFactory)target.getProviderFactory()).allowEditableFeatureType()!=DataStoreProviderFactory.NO) {

                getTaskStatus().message("Preparing the update of the indices" + msgRowCount);

                target.edit();

                EditableFeatureType ft = target.getDefaultFeatureType().getEditable();

                for (FeatureAttributeDescriptor attr : this.targetFeatureType) {

                    EditableFeatureAttributeDescriptor attr2 = (EditableFeatureAttributeDescriptor) ft.getAttributeDescriptor(attr.getName());

                    if (attr2 != null) {

                        if( attr2.isPrimaryKey() ) {

                            attr2.setAllowNull(false);

                        }

                        //attr2.setIsPrimaryKey(attr.isPrimaryKey()); ????

                        attr2.setIsIndexed(attr.isIndexed());

                        attr2.setIsAutomatic(attr.isAutomatic());

                        attr2.setIsReadOnly(attr.isReadOnly());

                    }

                }

                target.update(ft);

                getTaskStatus().message("Updating the indices" + msgRowCount);

                target.finishEditing();

            }

            if (this.getParameters().getUpdateTableStatistics()) {

                LOG.debug("Updating statistics");

                getTaskStatus().message("Updating statistics" + msgRowCount);

                explorer.updateTableStatistics(

                        openParams.getDBName(),

                        openParams.getSchema(),

                        openParams.getTable()

                );

            }

            LOG.info("Finish export");

            trans.commit();

            getTaskStatus().message("Exportation finished");

            getTaskStatus().terminate();

        } catch (Exception e) {

            LOG.warn("Can't export data.", e);

            trans.rollbackQuietly();

            getTaskStatus().message("Problems exporting data");

            throw new ExportException(e, targetFeature);

        } finally {

            if (it != null) {

                it.dispose();

            }

            featureSet.dispose();

            if (target != null) {

                if (target.isAppending()) {

                    try {

                        target.cancelEditing();

                    } catch (Exception ex) {

                        LOG.warn("Can't cancel editing.", ex);

                    }

                }

                target.dispose();

            }

            DataTransaction.close(trans);

            this.getTaskStatus().terminate();

            this.getTaskStatus().remove();

        }

    }

}