Application: gvSIG desktop

package org.gvsig.data.datastores.vectorial.db.jdbc;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.Statement;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.gvsig.data.commands.implementation.AbstractAttributeCommand;

import org.gvsig.data.commands.implementation.AbstractFeatureCommand;

import org.gvsig.data.commands.implementation.UpdateAttributeCommand;

import org.gvsig.data.commands.implementation.UpdateFeatureCommand;

import org.gvsig.data.datastores.vectorial.ISelectiveWriter;

import org.gvsig.data.datastores.vectorial.db.DBFeatureID;

import org.gvsig.data.datastores.vectorial.db.DBFeatureType;

import org.gvsig.data.datastores.vectorial.db.jdbc.exception.SQLException;

import org.gvsig.data.datastores.vectorial.db.jdbc.h2.H2Utils;

import org.gvsig.data.exception.ReadException;

import org.gvsig.data.exception.WriteException;

import org.gvsig.data.vectorial.AbstractFeatureStore;

import org.gvsig.data.vectorial.CreatedFeature;

import org.gvsig.data.vectorial.IFeature;

import org.gvsig.data.vectorial.IFeatureAttributeDescriptor;

import org.gvsig.data.vectorial.IFeatureID;

import org.gvsig.data.vectorial.IFeatureType;

import org.gvsig.metadata.IMetadata;

import org.gvsig.metadata.IMetadataManager;

import org.gvsig.metadata.MetadataManager;

public abstract class JDBCStore extends AbstractFeatureStore {

        protected Connection connection = null;

        protected String sqlSelectPart;

        protected String baseWhereClause = null;

        protected String baseOrder = null;

        protected String sqlSource = null;

        protected boolean useSqlSource = false;

        protected DBFeatureType featureType;

        protected IMetadata metadata;

        protected abstract Connection getConnection();

        protected abstract IFeature newFeatureInstance(DBFeatureType featureType,Object[] pk);

        protected abstract void loadValueFromResulset(ResultSet rs,IFeature feature,IFeatureAttributeDescriptor attr) throws ReadException;

        public boolean isEditable() {

                return !this.useSqlSource;

        }

        public String getSqlSelectPart() {

                return sqlSelectPart;

        }

        public String getBaseOrder() {

                return this.baseOrder;

        }

        public String getBaseWhereClause() {

                return baseWhereClause;

        }

        public boolean isUseSqlSource() {

                return this.useSqlSource;

        }

        public String getSqlSource() {

                return this.sqlSource;

        }

        protected abstract JDBCFeaturesWriter getFeaturesWriter();

        protected void doFinishEdition() throws WriteException, ReadException {

                Iterator commandsfeatures = null;

            JDBCFeaturesWriter writer = getFeaturesWriter();

            IFeatureType type = getDefaultFeatureType();

            if (writer instanceof ISelectiveWriter){

                    ISelectiveWriter selectiveWriter=(ISelectiveWriter)writer;

                    selectiveWriter.updateFeatureType(type);

                    selectiveWriter.preProcess();

                commandsfeatures = commands.getCommandsAttributeDeleted().iterator();

                    while( commandsfeatures.hasNext() ) {

                            Object obj=commandsfeatures.next();

                            if (obj instanceof AbstractAttributeCommand){

                                    IFeatureAttributeDescriptor attribute = ((AbstractAttributeCommand)obj).getAttributeDescriptor();

                                    selectiveWriter.deleteAttribute(attribute);

                            }

                    }

                    commandsfeatures = commands.getCommandsAttributeUpdated().iterator();

                    while( commandsfeatures.hasNext() ) {

                            Object obj=commandsfeatures.next();

                            if (obj instanceof AbstractAttributeCommand){

                                    IFeatureAttributeDescriptor oldAttribute = ((UpdateAttributeCommand)obj).getOldAttributeDescriptor();

                                    IFeatureAttributeDescriptor attribute = ((UpdateAttributeCommand)obj).getAttributeDescriptor();

                                    selectiveWriter.updateAttribute(oldAttribute,attribute);

                            }

                    }

                    commandsfeatures = commands.getCommandsAttributeInserted().iterator();

                    while( commandsfeatures.hasNext() ) {

                            Object obj=commandsfeatures.next();

                            if (obj instanceof AbstractAttributeCommand){

                                    IFeatureAttributeDescriptor attribute = ((AbstractAttributeCommand)obj).getAttributeDescriptor();

                                    selectiveWriter.insertAttribute(attribute);

                            }

                    }

                    commandsfeatures = commands.getCommandsFeatureDeleted().iterator();

                    while( commandsfeatures.hasNext() ) {

                            Object obj=commandsfeatures.next();

                            if (obj instanceof AbstractFeatureCommand){

                                    IFeature feature = ((AbstractFeatureCommand)obj).getFeature();

                                    if (feature instanceof CreatedFeature)

                                            continue;

                                    selectiveWriter.deleteFeature(feature);

                            }

                    }

                    commandsfeatures = commands.getCommandsFeatureUpdated().iterator();

                    while( commandsfeatures.hasNext() ) {

                            Object obj=commandsfeatures.next();

                            if (obj instanceof AbstractFeatureCommand){

                                    IFeature oldFeature = ((UpdateFeatureCommand)obj).getOldFeature();

                                    IFeature feature = ((UpdateFeatureCommand)obj).getFeature();

                                    if (featureManager.isDeleted(feature)){

                                            continue;

                                    }

                                    selectiveWriter.updateFeature(oldFeature,feature);

                            }

                    }

                    commandsfeatures = commands.getCommandsFeatureInserted().iterator();

                    while( commandsfeatures.hasNext() ) {

                            Object obj=commandsfeatures.next();

                            if (obj instanceof AbstractFeatureCommand){

                                    IFeature feature = ((AbstractFeatureCommand)obj).getFeature();

                                    if (featureManager.isDeleted(feature)){

                                            continue;

                                    }

                                    selectiveWriter.insertFeature(feature);

                            }

                    }

                    selectiveWriter.postProcess();

            }

        }

        public String getFilterForID(DBFeatureType fType, Object[] featureKey) {

                if (fType.getFieldsId().length != 1)

                        throw new UnsupportedOperationException("ID fields > 1");

                String id =fType.getFieldsId()[0];

                return id + " = " + objectToSqlString(featureKey[0]);

        }

        protected String objectToSqlString(Object obj) {

                if (obj instanceof String){

                        return "'"+ scapeString((String)obj) +"'";

                } else if (obj == null){

                        return "null";

                }else{

                        // OJO con otros tipos!!

                        return obj.toString();

                }

        }

        protected String scapeString(String str) {

                return str.replace("'", "''");

        }

        public IFeature getFeatureByID(IFeatureID id) throws ReadException {

                return getFeatureByID((DBFeatureType)this.getDefaultFeatureType(),((DBFeatureID)id).getKey());

        }

        public IFeatureType getDefaultFeatureType() {

                return this.featureType;

        }

        public IMetadata getMetadata() {

                if (metadata==null){

                        IMetadataManager manager=MetadataManager.getManager();

                        metadata=manager.create(this.getName());

                        //TODO: Apadir los meteadatos

                }

                return metadata;

        }

        public List getFeatureTypes() {

                ArrayList list = new ArrayList();

                list.add(this.featureType);

                return list;

        }

        public boolean isWithDefaultLegend() {

                // TODO Auto-generated method stub

                return false;

        }

        public Object getDefaultLabelingStrategy() {

                // TODO Auto-generated method stub

                return null;

        }

        public Object getDefaultLegend() {

                // TODO Auto-generated method stub

                return null;

        }

        public IFeature getFeatureByID(IFeatureType featureType2, Object[] featureKey) throws ReadException {

                //TODO: Tener en cuenta el FeatureType por si es distinto

                if (useSqlSource){

                        throw new ReadException(this.getName(),

                                        new UnsupportedOperationException("Unsuported featureByID in sqlSource mode"));

                }

                ResultSet rs=null;

                try{

                        this.open();

                        Statement st=this.getConnection().createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);

                        String sql = this.getSqlSelectPart() + " WHERE "+ this.getFilterForID(this.featureType, featureKey);

                        rs=st.executeQuery(sql);

                        if(rs.next()){

                                return createFeature(rs, this.featureType);

                        }

                } catch (java.sql.SQLException e) {

                        e.printStackTrace();

                        throw new ReadException(this.getName(), e);

                } finally{

                        if (rs != null)

                                try {

                                        rs.close();

                                } catch (java.sql.SQLException e) {

                                        // TODO ?????

                                        e.printStackTrace();

                                }

                }

                return null;

        }

        protected Object[] getPkFromResulset(ResultSet rs, DBFeatureType featureType) throws java.sql.SQLException{

                String[] fieldsId = featureType.getFieldsId();

                Object[] result = new Object[fieldsId.length];

                for (int i=0;i<fieldsId.length;i++){

                        result[i] = rs.getObject(fieldsId[i]);

                }

                return result;

        }

        protected IFeature createFeature(ResultSet rs, DBFeatureType featureType2) throws ReadException {

                JDBCFeature feature=null;

                if (featureType2 == null){

                        featureType2 = (DBFeatureType)this.getDefaultFeatureType();

                }

                Object[] pk;

                try {

                        pk = getPkFromResulset(rs, featureType2);

                        feature=(JDBCFeature)this.newFeatureInstance(featureType2, pk);

                        Iterator iter = featureType2.iterator();

                        while (iter.hasNext()) {

                                IFeatureAttributeDescriptor fad=(IFeatureAttributeDescriptor)iter.next();

                                this.loadValueFromResulset(rs, feature, fad);

                        }

                        return feature;

                } catch (java.sql.SQLException e) {

                        throw new ReadException(this.getName(),e);

                }

        }

}