Application: gvSIG desktop

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

import java.lang.ref.WeakReference;

import java.math.BigDecimal;

import java.nio.ByteBuffer;

import java.sql.Connection;

import java.sql.Date;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.sql.Timestamp;

import java.sql.Types;

import java.util.ArrayList;

import java.util.List;

import java.util.Locale;

import org.gvsig.data.IDataCollection;

import org.gvsig.data.IDataExplorer;

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

import org.gvsig.data.datastores.vectorial.db.jdbc.JDBCAttributeDescriptor;

import org.gvsig.data.datastores.vectorial.db.jdbc.JDBCFeaturesWriter;

import org.gvsig.data.datastores.vectorial.db.jdbc.JDBCStore;

import org.gvsig.data.datastores.vectorial.db.jdbc.postgresql.PostGIS2Geometry;

import org.gvsig.data.datastores.vectorial.db.jdbc.postgresql.PostgresqlFeatureID;

import org.gvsig.data.datastores.vectorial.db.jdbc.postgresql.PostgresqlStore;

import org.gvsig.data.datastores.vectorial.db.jdbc.postgresql.PostgresqlStoreParameters;

import org.gvsig.data.datastores.vectorial.db.jdbc.postgresql.PostgresqlStoreUtils;

import org.gvsig.data.exception.CloseException;

import org.gvsig.data.exception.InitializeException;

import org.gvsig.data.exception.OpenException;

import org.gvsig.data.exception.ReadException;

import org.gvsig.data.spatialprovisional.IExtent;

import org.gvsig.data.vectorial.IFeature;

import org.gvsig.data.vectorial.IFeatureAttributeDescriptor;

import org.gvsig.data.vectorial.IFeatureCollection;

import org.gvsig.data.vectorial.IFeatureID;

import org.gvsig.data.vectorial.IFeatureType;

import org.gvsig.metadata.IMetadata;

import org.postgis.PGgeometry;

import com.iver.cit.gvsig.fmap.core.IGeometry;

import com.iver.cit.gvsig.fmap.drivers.XTypes;

public class PostgresqlBinStore extends PostgresqlStore{

        public static final String CONNECTION_STRING = "postgresql";

        public static String DATASTORE_NAME = "PostgresqlStore";

        protected static Locale ukLocale = new Locale("en", "UK"); // English, UK version

    PostgresqlBinStoreParameters getParametersPostgresql(){

                return (PostgresqlBinStoreParameters)this.parameters;

        }

        public String getName() {

                return DATASTORE_NAME;

        }

        protected void initConnection() throws InitializeException{

                PostgresqlStoreParameters dParams = this.getParametersPostgresql();

                String dburl = dParams.getUrl();

                String dbuser = dParams.getUser();

                String dbpass = dParams.getPassw();

                this.connection = PostgresqlBinStoreUtils.getConnection(dburl, dbuser, dbpass);

        }

        public IDataCollection getDataCollection(IFeatureType type, String filter, String order) throws ReadException {

                if (useSqlSource ){

                        if (filter != null || order != null){

                                throw new ReadException(DATASTORE_NAME,

                                                new UnsupportedOperationException("Unsuported filter/order in sqlSource mode"));

                        }

                }

                if (type==null){

                        type=getDefaultFeatureType();

                }

                IFeatureCollection coll=null;

                if (featureManager == null){

                        coll=new PostgresqlBinFeatureCollection(this,type,filter,order);

                }else{

//                        if ((order != null && order != "")){

//                                coll=new H2FeatureCollectionWithFeatureID(featureManager,this,type,filter,order);

//                        } else{

//                                if (filter == null || filter == ""){

//                                        coll=new H2FeatureCollectionEditing(featureManager,this,type);

//                                } else {

//                                        coll=new H2FeatureCollectionEditingFiltered(featureManager,this,type,filter);

//                                }

//                        }

//

                }

                this.addObserver(new WeakReference(coll));

                return coll;

        }

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

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

                        String cursorName = PostgresqlBinStoreUtils.createCursorName();

                        String mSql="BEGIN";

                        st.execute(mSql);

                        mSql="declare " + cursorName + " binary cursor for " + sql;

                        st.execute(mSql);

                        rs=st.executeQuery("fetch 1 in "+ cursorName);

                        if (rs.isLast()) {

                                return null;

                        }else{

                                if(rs.next()){

                                        return this.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;

        }

        Connection getCurrentConnection(){

                return this.getConnection();

        }

        public boolean canAlterFeatureType() {

                return true;

        }

        public void open() throws OpenException {

                // FIXME: Resource Manager

        }

        public void close() throws CloseException {

                // FIXME: Resource Manager

                try {

                        connection.close();

                } catch (java.sql.SQLException e) {

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

                }

        }

        public void dispose() {

                // FIXME: Resource Manager

        }

        public JDBCFeaturesWriter getFeaturesWriter() {

//                IFeaturesWriter writer = new H2FeaturesWriter();

//                writer.init(this);

//                return writer;

                return null;

        }

        public IDataExplorer getExplorer() {

                // TODO Auto-generated method stub

                return null;

        }

        public boolean isEditable() {

                return false;

//                return super.isEditable();

        }

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

                String name = attr.getName();

                Object value = null;

                try {

                        value = getFieldValueFromBinaryCursor(rs, (JDBCAttributeDescriptor)attr);

                        if (attr.getDataType().equals(IFeatureAttributeDescriptor.TYPE_GEOMETRY)) {

                                feature.setGeometry(name,value);

                        } else {

                                feature.set(name, value);

                        }

                } catch (java.sql.SQLException e) {

                        throw new ReadException("CreateFeature",e);

                }

        }

        public IMetadata getMetadata() {

                if (metadata==null){

                        IMetadata tmp=super.getMetadata();

                        return tmp;

                }else{

                        return super.getMetadata();

                }

        }

        static Object getFieldValueFromBinaryCursor(ResultSet aRs, JDBCAttributeDescriptor attrDescriptor) throws java.sql.SQLException {

                int fieldId = attrDescriptor.ordinal();

                int sqlType = attrDescriptor.getSqlType();

                byte[] byteBuf = aRs.getBytes(fieldId+1);

                if (byteBuf == null)

                        return null;

                else {

                        ByteBuffer buf = ByteBuffer.wrap(byteBuf);

                        if (attrDescriptor.getDataType().equals(IFeatureAttributeDescriptor.TYPE_GEOMETRY)){

                                if (attrDescriptor.getDataType() == IFeatureAttributeDescriptor.TYPE_GEOMETRY){

                                        if (byteBuf == null)

                                                return null;

//                                        return wkbParser.parse(byteBuf);

                                        return null;

                                }

                        }

                        switch (sqlType) {

                        case Types.VARCHAR:

                                //FIXME Error

                                return aRs.getString(fieldId);

//                                return new String(buf.toString());

                        case Types.FLOAT:

                                return new Float(buf.getFloat());

                        case Types.DOUBLE:

                                return new Double(buf.getDouble());

                        case Types.REAL:

                                return new Float(buf.getFloat());

                        case Types.INTEGER:

                                return new Integer(buf.getInt());

                        case Types.BIGINT:

                                return new Long(buf.getLong());

                        case Types.BIT:

                                return new Boolean(byteBuf[0] == 1);

                        case Types.BOOLEAN:

                                return new Boolean(aRs.getBoolean(fieldId));

                        case Types.DATE:

                                long daysAfter2000 = buf.getInt() + 1;

                                long msecs = daysAfter2000*24*60*60*1000;

                                long real_msecs_date1 = (long) (XTypes.NUM_msSecs2000 + msecs);

                                Date realDate1 = new Date(real_msecs_date1);

                                return realDate1;

                        case Types.TIME:

                                // TODO:

                                // throw new RuntimeException("TIME type not implemented yet");

                                return "NOT IMPLEMENTED YET";

                        case Types.TIMESTAMP:

                                double segsReferredTo2000 = buf.getDouble();

                                long real_msecs = (long) (XTypes.NUM_msSecs2000 + segsReferredTo2000*1000);

                                Timestamp valTimeStamp = new Timestamp(real_msecs);

                                return valTimeStamp;

                        case Types.NUMERIC:

                                // System.out.println(metaData.getColumnName(fieldId) + " "

                                // + metaData.getColumnClassName(fieldId));

                                short ndigits = buf.getShort();

                                short weight = buf.getShort();

                                short sign = buf.getShort();

                                short dscale = buf.getShort();

                                String strAux;

                                if (sign == 0)

                                        strAux = "+";

                                else

                                        strAux = "-";

                                for (int iDigit = 0; iDigit < ndigits; iDigit++) {

                                        short digit = buf.getShort();

                                        strAux = strAux + digit;

                                        if (iDigit == weight)

                                                strAux = strAux + ".";

                                }

                                strAux = strAux + "0";

                                BigDecimal dec;

                                dec = new BigDecimal(strAux);

                                // System.out.println(ndigits + "_" + weight + "_" + dscale

                                // + "_" + strAux);

                                // System.out.println(strAux + " Big= " + dec);

                                return new Double(dec.doubleValue());

                        default:

                                //TODO ???

                                throw new RuntimeException("Unsuported Type");

                        }

                }

        }

        protected Object[] getPkFromResulsetBinary(ResultSet rs, DBFeatureType featureType) throws SQLException {

                String[] fieldsId = featureType.getFieldsId();

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

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

                        result[i] = getFieldValueFromBinaryCursor(

                                        rs,

                                        (JDBCAttributeDescriptor)featureType.get(

                                                        featureType.getFieldIndex(fieldsId[i])

                                                        )

                                );

                }

                return result;

        }

        IFeature createFeatureFromResulset(ResultSet rs, DBFeatureType featureType2) throws ReadException {

                return this.createFeature(rs, featureType2);

        }

}