| gvSIG desktop 1

       String fields = "ASBINARY(the_geom, 'XDR') as the_geom";

			jLabel.setSize(80, 19);

			jLabel.setLocation(151, 12);

			jLabel1.setBounds(149, 41, 82, 19);

			jLabel2.setBounds(121, 67, 110, 20);

			jLabel3.setBounds(26, 96, 205, 22);

			jLabel4.setBounds(125, 130, 106, 22);

			jTxtUser.setBounds(241, 12, 169, 19);

			jTxtUser.setText("postgres");

			jTxtPassword.setBounds(241, 39, 169, 20);

			jTxtNomTabla.setBounds(241, 66, 169, 20);

			jTxtSqlFields.setBounds(241, 96, 169, 24);

			jTxtSqlFields.setText("ASBINARY(the_geom, 'XDR')");

	public void close();

/*

 * WKBParser.java

 * Based in 

 * PostGIS extension for PostgreSQL JDBC driver - Binary Parser

 * 

 * NOTA: Es posible que lo mejor sea crear un PostGisGeometry que implemente

 * la interfaz IGeometry, y as? nos sirve de base para tener IGeometries

 * que encapsulan otras posibles geometr?as. Por ejemplo, un JTSGeometry.

 * De esta forma, un driver no necesitar?a reescribirse.

 * 

 * (C) 2005 Markus Schaber, schabios@logi-track.com

 * 

 * This library is free software; you can redistribute it and/or modify it under

 * the terms of the GNU Lesser General Public License as published by the Free

 * Software Foundation, either version 2.1 of the License.

 * 

 * This library 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 Lesser General Public License for more

 * details.

 * 

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

 * along with this library; if not, write to the Free Software Foundation, Inc.,

 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA or visit the web at

 * http://www.gnu.org.

 * 

 * $Id$

 */

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

import org.postgis.Geometry;

import org.postgis.GeometryCollection;

import org.postgis.LineString;

import org.postgis.LinearRing;

import org.postgis.MultiLineString;

import org.postgis.MultiPoint;

import org.postgis.MultiPolygon;

import org.postgis.Point;

import org.postgis.Polygon;

import org.postgis.binary.ByteGetter;

import org.postgis.binary.ValueGetter;

import org.postgis.binary.ByteGetter.BinaryByteGetter;

import org.postgis.binary.ByteGetter.StringByteGetter;

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

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

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

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

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

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

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

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

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

/**

 * Parse binary representation of geometries. Currently, only text rep (hexed)

 * implementation is tested.

 * 

 * It should be easy to add char[] and CharSequence ByteGetter instances,

 * although the latter one is not compatible with older jdks.

 * 

 * I did not implement real unsigned 32-bit integers or emulate them with long,

 * as both java Arrays and Strings currently can have only 2^31-1 elements

 * (bytes), so we cannot even get or build Geometries with more than approx.

 * 2^28 coordinates (8 bytes each).

 * 

 * @author markus.schaber@logi-track.com

 *  

 */

public class WKBParser {

    private boolean gHaveM, gHaveZ, gHaveS; // M, Z y SRID

    /**

     * Get the appropriate ValueGetter for my endianness

     * 

     * @param bytes The appropriate Byte Getter

     * 

     * @return the ValueGetter

     */    

    public static ValueGetter valueGetterForEndian(ByteGetter bytes) {

        if (bytes.get(0) == ValueGetter.XDR.NUMBER) { // XDR

            return new ValueGetter.XDR(bytes);

        } else if (bytes.get(0) == ValueGetter.NDR.NUMBER) {

            return new ValueGetter.NDR(bytes);

        } else {

            throw new IllegalArgumentException("Unknown Endian type:" + bytes.get(0));

        }

    }

    /**

     * Parse a hex encoded geometry

     * 

     * Is synchronized to protect offset counter. (Unfortunately, Java does not

     * have neither call by reference nor multiple return values.)

     */

    public synchronized IGeometry parse(String value) {

        StringByteGetter bytes = new ByteGetter.StringByteGetter(value);

        return parseGeometry(valueGetterForEndian(bytes));

    }

    /**

     * Parse a binary encoded geometry.

     * 

     * Is synchronized to protect offset counter. (Unfortunately, Java does not

     * have neither call by reference nor multiple return values.)

     */

    public synchronized IGeometry parse(byte[] value) {

        BinaryByteGetter bytes = new ByteGetter.BinaryByteGetter(value);

        return parseGeometry(valueGetterForEndian(bytes));

    }

    protected void parseTypeAndSRID(ValueGetter data)

    {

        byte endian = data.getByte(); //skip and test endian flag

        if (endian != data.endian) {

            throw new IllegalArgumentException("Endian inconsistency!");

        }

        int typeword = data.getInt();

        int realtype = typeword & 0x1FFFFFFF; //cut off high flag bits

        gHaveZ = (typeword & 0x80000000) != 0;

        gHaveM = (typeword & 0x40000000) != 0;

        gHaveS = (typeword & 0x20000000) != 0;

        int srid = -1;

        if (gHaveS) {

            srid = data.getInt();

        }

    }

    /** Parse a geometry starting at offset. */

    protected IGeometry parseGeometry(ValueGetter data) {

        byte endian = data.getByte(); //skip and test endian flag

        if (endian != data.endian) {

            throw new IllegalArgumentException("Endian inconsistency!");

        }

        int typeword = data.getInt();

        int realtype = typeword & 0x1FFFFFFF; //cut off high flag bits

        boolean haveZ = (typeword & 0x80000000) != 0;

        boolean haveM = (typeword & 0x40000000) != 0;

        boolean haveS = (typeword & 0x20000000) != 0;

        int srid = -1;

        if (haveS) {

            srid = data.getInt();

        }

        IGeometry result1;

        switch (realtype) {

        case Geometry.POINT :

            result1 = ShapeFactory.createPoint2D(parsePoint(data, haveZ, haveM));

            break;

        case Geometry.LINESTRING :

            result1 = ShapeFactory.createGeometry(parseLineString(data, haveZ, haveM));

            break;

        case Geometry.POLYGON :

            result1 = ShapeFactory.createGeometry(parsePolygon(data, haveZ, haveM));

            break;

        case Geometry.MULTIPOINT :

            result1 = parseMultiPoint(data);

            break;

        case Geometry.MULTILINESTRING :

            result1 = ShapeFactory.createGeometry(parseMultiLineString(data));

            break;

        case Geometry.MULTIPOLYGON :

            result1 = ShapeFactory.createGeometry(parseMultiPolygon(data));

            break;

        case Geometry.GEOMETRYCOLLECTION :

            result1 = parseCollection(data);

            break;

        default :

            throw new IllegalArgumentException("Unknown Geometry Type!");

        }

        /*Geometry result = result1;

        if (haveS) {

            result.setSrid(srid);

        } */

        return result1;

    }

    private FPoint2D parsePoint(ValueGetter data, boolean haveZ, boolean haveM) {

        double X = data.getDouble();

        double Y = data.getDouble();

        FPoint2D result;

        if (haveZ) {

            double Z = data.getDouble();

            result = new FPoint3D(X, Y, Z);

        } else {

            result = new FPoint2D(X, Y);

        }

        if (haveM) {

            System.err.println("M no soportado. (WKBParser de gvSIG, dentro de parsePoint)");

            double m = data.getDouble();

            // result.setM(m);

        }

        return result;

    }

    /** Parse an Array of "full" Geometries */

    private void parseGeometryArray(ValueGetter data, IGeometry[] container) {

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

            container[i] = parseGeometry(data);

        }

    }

    /**

     * Parse an Array of "slim" Points (without endianness and type, part of

     * LinearRing and Linestring, but not MultiPoint!

     * 

     * @param haveZ

     * @param haveM

     */

    private FPoint2D[] parsePointArray(ValueGetter data, boolean haveZ, boolean haveM) {

        int count = data.getInt();

        FPoint2D[] result = new FPoint2D[count];

        for (int i = 0; i < count; i++) {

            result[i] = parsePoint(data, haveZ, haveM);

        }

        return result;

    }

    private FMultiPoint2D parseMultiPoint(ValueGetter data) {

        FPoint2D[] points = new FPoint2D[data.getInt()];

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

        {

            parseTypeAndSRID(data);

            parsePoint(data, gHaveZ, gHaveM);

        }

        return new FMultiPoint2D(points);

    }

    private FPolyline2D parseLineString(ValueGetter data, boolean haveZ, boolean haveM) {

        FPoint2D[] points = parsePointArray(data, haveZ, haveM);

        GeneralPathX gp = new GeneralPathX();

        gp.moveTo(points[0].getX(), points[0].getY());

        for (int i = 1; i< points.length; i++)

        {

            gp.lineTo(points[i].getX(), points[i].getY());

        }

        return new FPolyline2D(gp);

    }

    private FPolygon2D parseLinearRing(ValueGetter data, boolean haveZ, boolean haveM) {

        FPoint2D[] points = parsePointArray(data, haveZ, haveM);

        GeneralPathX gp = new GeneralPathX();

        gp.moveTo(points[0].getX(), points[0].getY());

        for (int i = 1; i< points.length; i++)

        {

            gp.lineTo(points[i].getX(), points[i].getY());

        }

        return new FPolygon2D(gp);

    }

    private FPolygon2D parsePolygon(ValueGetter data, boolean haveZ, boolean haveM) {

        int count = data.getInt();

        FPolygon2D[] rings = new FPolygon2D[count];

        for (int i = 0; i < count; i++) {

            rings[i] = parseLinearRing(data, haveZ, haveM);

        }

        return rings[0]; //new FPolygon2D(rings[0]);

    }

    private FPolyline2D parseMultiLineString(ValueGetter data) {

        int count = data.getInt();

        FPolyline2D[] strings = new FPolyline2D[count];   

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

        {

            parseTypeAndSRID(data);

            strings[i] = parseLineString(data, gHaveZ, gHaveM);

        }

        // parseGeometryArray(data, strings);

        return strings[0]; //new MultiLineString(strings);

    }

    private FPolygon2D parseMultiPolygon(ValueGetter data) {

        int count = data.getInt();

        FPolygon2D[] polys = new FPolygon2D[count];

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

        {

            parseTypeAndSRID(data);

            polys[i] = parsePolygon(data, gHaveZ, gHaveM);

        }

        // parseGeometryArray(data, polys);

        return polys[0]; //new MultiPolygon(polys);

    }

    private FGeometryCollection parseCollection(ValueGetter data) {

        int count = data.getInt();

        IGeometry[] geoms = new IGeometry[count];

        parseGeometryArray(data, geoms);

        return new FGeometryCollection(geoms);

    }

}

    protected boolean bCursorActivo = false;

    protected Statement st;

    public void close()

    {

        try {

            if (bCursorActivo)

            {

                st.execute("CLOSE wkb_cursor");

                bCursorActivo = false;

            }

        } catch (SQLException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

	        st.setFetchSize(500);

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

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

      String dbtable = "vias";

            String strSQL = "select ASBINARY(the_geom) as geom from " + dbtable;

            Statement s = conn.createStatement();

			// s.execute("begin");

            // Statement s = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);

            s.setFetchSize(2000);

			s.execute("declare wkb_cursor binary cursor for " + strSQL);

			ResultSet r =	s.executeQuery("fetch forward all in wkb_cursor");

            // ResultSet r = s.executeQuery(strSQL);

			WKBParser parser = new WKBParser();

              // Object obj = r.getObject(1);

              byte[] arrayByte = r.getBytes(1);

              IGeometry gp = parser.parse(arrayByte);

import java.sql.Statement;

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

    private WKBParser parser = new WKBParser();

    Statement st;

        try

	        if (rs.isAfterLast())

	        {            

	            rs.close();

	            return false;

	        }

	        else

	            return true;

        catch (Exception e)

        {

            e.printStackTrace();

        }

        return false;

        byte[] data = rs.getBytes(1);	        

        geom = parser.parse(data);

	        st.execute("declare wkb_cursor binary cursor for " + sqlOrig);

	        rs = st.executeQuery("fetch forward all in wkb_cursor");

	        st.execute("BEGIN"); 

	        bCursorActivo = true; 

	        // rs = st.executeQuery(sqlOrig);

            metaData = rs.getMetaData(); 

            if (bCursorActivo)

                close();

	        st.execute("declare wkb_cursor binary cursor for " + sql);

	        ResultSet rs = st.executeQuery("fetch forward all in wkb_cursor");

            // st.execute("BEGIN");

            bCursorActivo = true;

            // ResultSet rs = st.executeQuery(sql);

        dbAdapter.start();

            	    dbAdapter.stop();

        dbAdapter.stop();

	public double getZ()

	{

	    return z;

	}

	public static IGeometry createPoint2D(FPoint2D p) {

		return new FGeometry(p);

	}

	    ((VectorialDatabaseDriver)driver).close();

			    {			        

			        long t1 = System.currentTimeMillis();

					long t2 = System.currentTimeMillis();

					System.out.println("Layer " + lyr.getName() + " "

					        + (t2-t1) + " milisecs.");	

			    }