Application: gvSIG desktop

package com.iver.cit.gvsig.fmap.drivers.jdbc.postgis;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.sql.Types;

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

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

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

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

import com.iver.cit.gvsig.fmap.edition.EditionException;

import com.iver.cit.gvsig.fmap.edition.IRowEdited;

import com.iver.cit.gvsig.fmap.edition.ISpatialWriter;

import com.iver.cit.gvsig.fmap.edition.writers.AbstractWriter;

import com.iver.cit.gvsig.fmap.layers.FLayer;

public class PostGISWriter extends AbstractWriter implements ISpatialWriter {

        private int numRows;

        private DBLayerDefinition lyrDef;

        private Connection conex;

        private Statement st;

        private boolean bCreateTable;

        private boolean bWriteAll;

        private double flatness;

        /**

         * Useful to create a layer from scratch Call setFile before using this

         * function

         * 

         * @param lyrDef

         * @throws IOException

         * @throws DriverException

         */

        public void initialize(ILayerDefinition lyrD) throws EditionException {

                this.lyrDef = (DBLayerDefinition) lyrD;

                conex = lyrDef.getConnection();

                try {

                        st = conex.createStatement();

                        if (bCreateTable) {

                                try {

                                        st.execute("DROP TABLE " + lyrDef.getTableName() + ";");

                                } catch (SQLException e1) {

                                        // Si no existe la tabla, no hay que borrarla.

                                }

                                String sqlCreate = PostGIS.getSqlCreateSpatialTable(lyrDef,

                                                lyrDef.getFieldsDesc(), true);

                                System.out.println("sqlCreate =" + sqlCreate);

                                st.execute(sqlCreate);

                                String sqlAlter = PostGIS.getSqlAlterTable(lyrDef);

                                System.out.println("sqlAlter =" + sqlAlter);

                                st.execute(sqlAlter);

                                // CREATE TABLE PARKS ( PARK_ID int4, PARK_NAME varchar(128),

                                // PARK_DATE date, PARK_TYPE varchar(2) );

                                // SELECT AddGeometryColumn('parks_db', 'parks', 'park_geom',

                                // 128,

                                // 'MULTIPOLYGON', 2 );

                                /*

                                 * BEGIN; INSERT INTO ROADS_GEOM (ID,GEOM,NAME ) VALUES

                                 * (1,GeometryFromText('LINESTRING(191232 243118,191108

                                 * 243242)',-1),'Jeff Rd'); INSERT INTO ROADS_GEOM (ID,GEOM,NAME )

                                 * VALUES (2,GeometryFromText('LINESTRING(189141 244158,189265

                                 * 244817)',-1),'Geordie Rd'); COMMIT;

                                 */

                        }

                        conex.setAutoCommit(false);

                } catch (SQLException e) {

                        e.printStackTrace();

                        throw new EditionException(e);

                }

        }

        public void preProcess() throws EditionException {

                numRows = 0;

        // ATENTION: We will transform (in PostGIS class; doubleQuote())

        // to UTF-8 strings. Then, we tell the PostgreSQL server

        // that we will use UTF-8, and it can translate

        // to its charset

        // Note: we have to translate to UTF-8 because

        // the server cannot manage UTF-16

        ResultSet rsAux;

                try {

                        rsAux = st.executeQuery("SHOW server_encoding;");

                rsAux.next();

                String serverEncoding = rsAux.getString(1);

                System.out.println("Server encoding = " + serverEncoding);

                // st.execute("SET CLIENT_ENCODING TO 'UNICODE';");

                // Intentamos convertir nuestras cadenas a ese encode.

                PostGIS.toEncode = serverEncoding;

                } catch (SQLException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

        }

        public void process(IRowEdited row) throws EditionException {

                String sqlInsert;

                try {

                        // System.out.println("Escribiendo numReg=" + numReg + " con

                        // STATUS=" + row.getStatus());

                        switch (row.getStatus()) {

                        case IRowEdited.STATUS_ADDED:

                                IFeature feat = (IFeature) row.getLinkedRow();

                                sqlInsert = PostGIS.getSqlInsertFeature(lyrDef, feat);

                                System.out.println("sql = " + sqlInsert);

                                st.execute(sqlInsert);

                                break;

                        case IRowEdited.STATUS_MODIFIED:

                                IFeature featM = (IFeature) row.getLinkedRow();

                                if (bWriteAll) {

                                        sqlInsert = PostGIS.getSqlInsertFeature(lyrDef, featM);

                                        System.out.println("sql = " + sqlInsert);

                                        st.execute(sqlInsert);

                                } else {

                                        String sqlModify = PostGIS

                                                        .getSqlModifyFeature(lyrDef, featM);

                                        System.out.println("sql = " + sqlModify);

                                        st.execute(sqlModify);

                                }

                                break;

                        case IRowEdited.STATUS_ORIGINAL:

                                IFeature featO = (IFeature) row.getLinkedRow();

                                if (bWriteAll) {

                                        sqlInsert = PostGIS.getSqlInsertFeature(lyrDef, featO);

                                        st.execute(sqlInsert);

                                }

                                break;

                        case IRowEdited.STATUS_DELETED:

                                String sqlDelete = PostGIS.getSqlDeleteFeature(lyrDef, row);

                                System.out.println("sql = " + sqlDelete);

                                st.execute(sqlDelete);

                                break;

                        }

                        numRows++;

                } catch (SQLException e) {

                        e.printStackTrace();

                        throw new EditionException(e);

                }

        }

        public void postProcess() throws EditionException {

                try {

                        conex.setAutoCommit(true);

                } catch (SQLException e) {

                        e.printStackTrace();

                        throw new EditionException(e);

                }

        }

        public String getName() {

                return "PostGIS Writer";

        }

        public boolean canWriteGeometry(int gvSIGgeometryType) {

                switch (gvSIGgeometryType) {

                case FShape.POINT:

                        return true;

                case FShape.LINE:

                        return true;

                case FShape.POLYGON:

                        return true;

                case FShape.ARC:

                        return false;

                case FShape.ELLIPSE:

                        return false;

                case FShape.MULTIPOINT:

                        return true;

                case FShape.TEXT:

                        return false;

                }

                return false;

        }

        public boolean canWriteAttribute(int sqlType) {

                switch (sqlType) {

                case Types.DOUBLE:

                case Types.FLOAT:

                case Types.INTEGER:

                case Types.BIGINT:

                        return true;

                case Types.DATE:

                        return true;

                case Types.BIT:

                case Types.BOOLEAN:

                        return true;

                case Types.VARCHAR:

                case Types.CHAR:

                case Types.LONGVARCHAR:

                        return true; 

                }

                return false;

        }

        /**

         * @return Returns the bCreateTable.

         */

        public boolean isCreateTable() {

                return bCreateTable;

        }

        /**

         * @param createTable

         *            The bCreateTable to set.

         */

        public void setCreateTable(boolean createTable) {

                bCreateTable = createTable;

        }

        /**

         * @return Returns the bWriteAll.

         */

        public boolean isWriteAll() {

                return bWriteAll;

        }

        /**

         * @param writeAll

         *            The bWriteAll to set.

         */

        public void setWriteAll(boolean writeAll) {

                bWriteAll = writeAll;

        }

        public void initialize(FLayer layer) throws EditionException {

        }

        public void setFlatness(double flatness) {

                this.flatness = flatness;

        }

}