/ - Diff - Application: gvSIG desktop - gvSIG

     	private String totalOrder;
     	private int fetchSize=5000;
     	PostgresqlFeatureCollection(PostgresqlStore store,IFeatureType type, String filter, String order) {
     	PostgresqlFeatureCollection(JDBCStore store,IFeatureType type, String filter, String order) {
     		this.store=store;
     		this.featureType=(DBFeatureType)type;
     		this.filter=filter;
-...
     				IFeature feature=null;
     				try {
     					if(rs.next()){
     						feature = PostgresqlStoreUtils.createFeature(this.store, this.rs, this.featureType);
     						feature = this.store.createFeatureFromResulset(this.rs, this.featureType);
     					} else {
     						rs.close();
     //						rs.getStatement().close();

     	protected class PostgresIterator implements Iterator{
     		private Iterator dbIter;
     		private Iterator mIter;
     		public PostgresIterator(JDBCStore store,DBFeatureType featureType,String sql, int fetchSize,FeatureManager featureManager) throws ReadException{
     		public PostgresIterator(PostgresqlStore store,DBFeatureType featureType,String sql, int fetchSize,FeatureManager featureManager) throws ReadException{
     			this.dbIter = new IteratorDB(store,featureType,sql,fetchSize,featureManager);
     			this.mIter = new IteratorMemory(featureType,featureManager);
+    		}
-...
     		private boolean nextChecked=false;
     		private IFeature feature;
     		private ResultSet rs;
     		private JDBCStore store;
     		private PostgresqlStore store;
     		private DBFeatureType featureType;
     		private boolean rsEOF=false;
     		private FeatureManager featureManager;
-...
     		private int index;
     		public IteratorDB(JDBCStore store, DBFeatureType featureType,String sql,int fetchSize, FeatureManager featureManager) throws ReadException{
     		public IteratorDB(PostgresqlStore store, DBFeatureType featureType,String sql,int fetchSize, FeatureManager featureManager) throws ReadException{
     			this.store = store;
     			this.featureType = featureType;
     			this.featureManager= featureManager;
-...
     			IFeature feature=null;
     			try {
     				if(rs.next()){
     					feature=PostgresqlStoreUtils.createFeature(this.store, this.rs, featureType);
     					feature=this.store.createFeatureFromResulset(this.rs, featureType);
+    				}
     			} catch (java.sql.SQLException e) {
     				throw new RuntimeException(

     		private ResultSet rs;
     		private boolean nextChecked=false;
     		private IFeature feature;
     		private JDBCStore store;
     		private PostgresqlStore store;
     		private DBFeatureType featureType;
     		private String sql;
     		private int fetchSize;
-...
     		private long position;
     		private boolean rsEOF=false;
     		public PostgresIterator(JDBCStore store, DBFeatureType featureType,String sql,int fetchSize)  throws ReadException{
     		public PostgresIterator(PostgresqlStore store, DBFeatureType featureType,String sql,int fetchSize)  throws ReadException{
     			this.sql = sql;
     			this.store = store;
     			this.featureType = featureType;
-...
     			IFeature feature=null;
     			try {
     				if(rs.next()){
     					feature=PostgresqlStoreUtils.createFeature(this.store, this.rs, featureType);
     					feature=this.store.createFeatureFromResulset(this.rs, featureType);
+    				}
     			} catch (java.sql.SQLException e) {
     				throw new RuntimeException(

     import org.gvsig.data.datastores.vectorial.db.DBAttributeDescriptor;
     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.JDBCFeature;
     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.JDBCTypes;
     import org.gvsig.data.exception.InitializeException;
     import org.gvsig.data.exception.InitializeWriterException;
-...
     	DBFeatureType featureType;
     	boolean bCreateTable=false;
     	private String toEncode;
     	PostgresqlStore store;
     	JDBCStore store;
     	PostgresqlStoreParameters parameters;
     	private PreparedStatement insertSt;
-...
+    	}
     	public void init(IFeatureStore store) {
     		this.store = (PostgresqlStore)store;
     		this.parameters=(PostgresqlStoreParameters)store.getParameters();
     		PostgresqlStore pgStore = (PostgresqlStore)store;
     		this.store = pgStore;
     		this.parameters=pgStore.getParametersPostgresql();
     		this.featureType = (DBFeatureType)this.store.getDefaultFeatureType();
     		conex = this.store.getConnection();
     		conex = pgStore.getConnection();
+    	}
-...
     		StringBuffer sqlBuf = new StringBuffer("DELETE FROM "
     				+ this.parameters.tableID() + " WHERE ");
     		String sql = null;
     		sqlBuf.append(PostgresqlStoreUtils.getFilterForID(dbFeatureType, feature));
     		sqlBuf.append(((JDBCFeature)feature).getFilterForID());
     		sql = sqlBuf.toString();
     		return sql;

trunk/libraries/libDataSourceDBBaseDrivers/src/org/gvsig/data/datastores/vectorial/db/jdbc/postgresql/PostgresqlFeatureCollectionWithFeatureID.java
10	10
11	11	public class PostgresqlFeatureCollectionWithFeatureID extends AbstractJDBCDataFeatureCollectionWithFeatureID {
12	12
13		PostgresqlFeatureCollectionWithFeatureID(FeatureManager fm,PostgresqlStore store,IFeatureType type, String filter,String order) throws ReadException {
	13	PostgresqlFeatureCollectionWithFeatureID(FeatureManager fm,JDBCStore store,IFeatureType type, String filter,String order) throws ReadException {
14	14	init(fm, store, type, filter, order);
15	15	}
16	16
17	17	public IFeatureCollection newBaseDataFeatureCollection(JDBCStore store, IFeatureType featureType, String filter, String order) {
18		return new PostgresqlFeatureCollection((PostgresqlStore)store,this.featureType,filter,order);
	18	return new PostgresqlFeatureCollection((JDBCStore)store,this.featureType,filter,order);
19	19	}
20	20
21	21	}

     import java.lang.ref.WeakReference;
     import java.sql.Connection;
     import java.sql.ResultSet;
     import java.sql.Statement;
     import java.util.ArrayList;
     import java.util.List;
     import java.util.Iterator;
     import java.util.Locale;
     import org.gvsig.data.IDataCollection;
     import org.gvsig.data.IDataExplorer;
     import org.gvsig.data.IDataStoreParameters;
     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.JDBCFeature;
     import org.gvsig.data.datastores.vectorial.db.jdbc.JDBCFeaturesWriter;
     import org.gvsig.data.datastores.vectorial.db.jdbc.JDBCStore;
     import org.gvsig.data.exception.CloseException;
-...
     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.gvsig.metadata.IMetadataManager;
     import org.gvsig.metadata.MetadataManager;
     import org.postgis.PGgeometry;
     import com.iver.cit.gvsig.fmap.core.IGeometry;
     public class PostgresqlStore extends JDBCStore{
     	public static final String CONNECTION_STRING = "postgresql";
     	public static String DATASTORE_NAME = "PostgresqlStore";
     	protected static Locale ukLocale = new Locale("en", "UK"); // English, UK version
         private DBFeatureType featureType;
     	protected IMetadata metadata;
     	PostgresqlStoreParameters getParametersPostgresql(){
         PostgresqlStoreParameters getParametersPostgresql(){
     		return (PostgresqlStoreParameters)this.parameters;
+    	}
-...
     		return coll;
+    	}
     	public IFeature getFeatureByID(IFeatureID id) throws ReadException {
     		return getFeatureByID(featureType,((PostgresqlFeatureID)id).getKey());
+    	}
     	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 "+ PostgresqlStoreUtils.getFilterForID(this.featureType, featureKey);
     			rs=st.executeQuery(sql);
     			if (rs.isLast()) {
     				return null;
     			}else{
     				if(rs.next()){
     					return PostgresqlStoreUtils.createFeature(this, 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 Connection getConnection(){
     		// FIXME: OJO REsource manager
     		return this.connection;
-...
     		return writer;
+    	}
     	public IDataExplorer getExplorer() {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     	public IMetadata getMetadata() {
     		if (metadata==null){
     			IMetadataManager manager=MetadataManager.getManager();
     			metadata=manager.create(DATASTORE_NAME);
     			//TODO: Apadir los meteadatos
     			IMetadata tmp=super.getMetadata();
     			return tmp;
     		}else{
     			return super.getMetadata();
+    		}
     		return metadata;
+    	}
     	public IFeatureType getDefaultFeatureType() {
     		// TODO Auto-generated method stub
     		return this.featureType;
+    	}
     	public Object getDefaultLabelingStrategy() {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     	protected void loadValueFromResulset(ResultSet rs, IFeature feature, IFeatureAttributeDescriptor attr) throws ReadException {
     		IGeometry geom = null;
     		String name = attr.getName();
     		try {
     			if (attr.getDataType().equals(IFeatureAttributeDescriptor.TYPE_GEOMETRY)) {
     	public Object getDefaultLegend() {
     		// TODO Auto-generated method stub
     		return null;
     				PGgeometry data =(PGgeometry)rs.getObject(name);
     				if (data == null) {
     					geom = null;
     				} else{
     					geom = PostGIS2Geometry.getGeneralPath(data);
+    				}
     				feature.setGeometry(name,geom);
     			} else {
     				feature.set(name, rs.getObject(name));
+    			}
     		} catch (java.sql.SQLException e) {
     			throw new ReadException("CreateFeature",e);
+    		}
+    	}
     	public List getFeatureTypes() {
     		ArrayList list = new ArrayList();
     		list.add(this.featureType);
     		return list;
     	protected IFeature newFeatureInstance(DBFeatureType featureType, Object[] pk) {
     		return new PostgresqlFeature(featureType,this,pk);
+    	}
     	public boolean isWithDefaultLegend() {
     		// TODO Auto-generated method stub
     		return false;
     	IFeature createFeatureFromResulset(ResultSet rs, DBFeatureType featureType2) throws ReadException {
     		return this.createFeature(rs, featureType2);
+    	}
     	public IDataExplorer getExplorer() {
     		// TODO Auto-generated method stub
     		return null;
+    	}
+    }

+    	}
     	static String getFilterForID(DBFeatureType fType, IFeature feature){
     		return getFilterForID(fType, getPkFromFeature(feature,fType));
+    	}
     	static String getFilterForID(DBFeatureType fType, Object[] featureKey){
     		//TODO: Ojo para los multiples
     		if (fType.getFieldsId().length != 1)
     			throw new UnsupportedOperationException("ID fields > 1");
     		String id =fType.getFieldsId()[0];
     		return id + " = " + objectToSqlString(featureKey[0]);
+    	}
     	static 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();
+    		}
+    	}
     	static String scapeString(String str){
     		return str.replace("'", "''");
+    	}
     	static Connection getConnection(String dbUrl, String dbUser, String dbPass) throws InitializeException {
     		//TODO: Aqu? habria que implementar la llamada
     		//      al Resource Manager para comprobar si ya hay
-...
     	protected static 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 static Object[] getPkFromFeature(IFeature feature, DBFeatureType featureType){
     		String[] fieldsId = featureType.getFieldsId();
     		Object[] result = new Object[fieldsId.length];
     		for (int i=0;i<fieldsId.length;i++){
     			result[i] = feature.get(fieldsId[i]);
+    		}
     		return result;
+    	}
     	static IFeature createFeature(JDBCStore store,ResultSet rs,DBFeatureType featureType) throws ReadException{
     		JDBCFeature feature=null;
     		Object[] pk;
     		try {
     			pk = getPkFromResulset(rs, featureType);
     			feature=new PostgresqlFeature(featureType,store,pk);
     			Iterator iter = featureType.iterator();
     			IGeometry geom = null;
     			while (iter.hasNext()) {
     				IFeatureAttributeDescriptor fad=(IFeatureAttributeDescriptor)iter.next();
     				if (fad.getDataType().equals(IFeatureAttributeDescriptor.TYPE_GEOMETRY)) {
     					PGgeometry data =(PGgeometry)rs.getObject(fad.getName());
     					if (data == null) {
     						geom = null;
     					} else{
     						geom = PostGIS2Geometry.getGeneralPath(data);
+    					}
     					feature.setGeometry(fad.getName(),geom);
     				} else {
     					feature.set(fad.getName(), rs.getObject(fad.getName()));
+    				}
+    			}
     			return feature;
     		} catch (java.sql.SQLException e) {
     			throw new ReadException("CreateFeature",e);
+    		}
+    	}
     	static String addLimitsToSQL(String aSql,int fetchSize,int page){
     		return aSql+ " limit " + fetchSize + " offset " + (fetchSize*page);
+    	}
     	static String getDefaultSchema(Connection conn, String catalog) throws InitializeException {
     		//TODO
     		return null;
+    	}
+    }

     import com.vividsolutions.jts.io.WKBWriter;
     public class H2Utils {
     	private static WKBParser2 wkbParser = new WKBParser2();
     	static String getFilterForID(DBFeatureType fType, IFeature feature){
     		return getFilterForID(fType, getPkFromFeature(feature,fType));
+    	}
     	static String getFilterForID(DBFeatureType fType, Object[] featureKey){
     		//TODO: Ojo para los multiples
     		if (fType.getFieldsId().length != 1)
     			throw new UnsupportedOperationException("ID fields > 1");
     		String id =fType.getFieldsId()[0];
     		return id + " = " + objectToSqlString(featureKey[0]);
+    	}
     	static String getDefaultSchema(Connection conn, String catalog) throws InitializeException {
     		String sql= "SELECT * FROM INFORMATION_SCHEMA.SCHEMATA WHERE IS_DEFAULT = TRUE";
-...
+    		}
     		return schema;
+    	}
     	private static void loadFieldsToFeatureType(Connection conn,H2StoreParameters params,DBFeatureType featureType) throws ReadException{
-...
     		JDBCAttributeDescriptor column= new JDBCAttributeDescriptor();
     		try {
     			column.setName(rsMetadata.getColumnName(colIndex));
     			column.setCaseSensitive(rsMetadata.isCaseSensitive(colIndex));
     			column.setSqlType(rsMetadata.getColumnType(colIndex));
     			switch (rsMetadata.getColumnType(colIndex)) {
     			column.setAllowNull(rsMetadata.isNullable(colIndex) == ResultSetMetaData.columnNullable);
     			column.setAutoIncrement(rsMetadata.isAutoIncrement(colIndex));
     			column.setReadOnly(rsMetadata.isReadOnly(colIndex));
     			column.setWritable(rsMetadata.isWritable(colIndex));
     			column.setClassName(rsMetadata.getColumnClassName(colIndex));
     			column.setCatalogName(rsMetadata.getCatalogName(colIndex));
     			column.setDefinitelyWritable(rsMetadata.isDefinitelyWritable(colIndex));
     			column.setLabel(rsMetadata.getColumnLabel(colIndex));
     			column.setSchemaName(rsMetadata.getSchemaName(colIndex));
     			column.setTableName(rsMetadata.getTableName(colIndex));
     			column.setCatalogName(rsMetadata.getCatalogName(colIndex));
     			column.setSqlTypeName(rsMetadata.getColumnTypeName(colIndex));
     			column.setSearchable(rsMetadata.isSearchable(colIndex));
     			column.setSigned(rsMetadata.isSigned(colIndex));
     			column.setCurrency(rsMetadata.isCurrency(colIndex));
     			column.setPrecision(rsMetadata.getPrecision(colIndex));
     			column.setSize(rsMetadata.getColumnDisplaySize(colIndex));			switch (rsMetadata.getColumnType(colIndex)) {
     			case java.sql.Types.INTEGER:
     				column.setType(IFeatureAttributeDescriptor.TYPE_INT);
     				break;
-...
     				break;
     			case java.sql.Types.REAL:
     				column.setType(IFeatureAttributeDescriptor.TYPE_DOUBLE);
     //				column.setPrecision(rsMetadata.getInt("DECIMAL_DIGITS"));
     				break;
     			case java.sql.Types.DOUBLE:
     				column.setType(IFeatureAttributeDescriptor.TYPE_DOUBLE);
     //				column.setPrecision(rsMetadata.getInt("DECIMAL_DIGITS"));
     				break;
     			case java.sql.Types.CHAR:
     				column.setType(IFeatureAttributeDescriptor.TYPE_STRING);
     				column.setSize(rsMetadata.getColumnDisplaySize(colIndex));
     				break;
     			case java.sql.Types.VARCHAR:
     				column.setType(IFeatureAttributeDescriptor.TYPE_STRING);
     				column.setSize(rsMetadata.getColumnDisplaySize(colIndex));
     				break;
     			case java.sql.Types.FLOAT:
     				column.setType(IFeatureAttributeDescriptor.TYPE_FLOAT);
     				column.setSize(rsMetadata.getColumnDisplaySize(colIndex));
     				break;
     			case java.sql.Types.DECIMAL:
     				column.setType(IFeatureAttributeDescriptor.TYPE_FLOAT);
     				column.setSize(rsMetadata.getColumnDisplaySize(colIndex));
     //				column.setPrecision(rsMetadata.getInt("DECIMAL_DIGITS"));
     				break;
     			case java.sql.Types.DATE:
     				column.setType(IFeatureAttributeDescriptor.TYPE_DATE);
-...
     		return conn;
+    	}
     	static 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;
+    	}
     	static Object[] getPkFromFeature(IFeature feature, DBFeatureType featureType){
     		String[] fieldsId = featureType.getFieldsId();
     		Object[] result = new Object[fieldsId.length];
     		for (int i=0;i<fieldsId.length;i++){
     			result[i] = feature.get(fieldsId[i]);
+    		}
     		return result;
+    	}
     	static IFeature createFeature(JDBCStore store,ResultSet rs,IFeatureType featureType) throws ReadException{
     		JDBCFeature feature=null;
     		if (featureType == null){
     			featureType = store.getDefaultFeatureType();
+    		}
     		Object[] pk;
     		try {
     			pk = getPkFromResulset(rs, (DBFeatureType) store.getDefaultFeatureType());
     			feature=new H2Feature(featureType,store,pk);
     			Iterator iter = featureType.iterator();
     			IGeometry geom = null;
     			while (iter.hasNext()) {
     				IFeatureAttributeDescriptor fad=(IFeatureAttributeDescriptor)iter.next();
     				if (fad.getDataType().equals(IFeatureAttributeDescriptor.TYPE_GEOMETRY)) {
     					byte[] data = rs.getBytes(fad.getName());
     					if (data == null) {
     						geom = null;
     					} else{
     						geom = wkbParser.parse(data);
+    					}
     //					feature.setDefaultGeometry(geom);
     					feature.setGeometry(fad.getName(),geom);
     				} else {
     					feature.set(fad.getName(), rs.getObject(fad.getName()));
+    				}
+    			}
     			return feature;
     		} catch (java.sql.SQLException e) {
     			throw new ReadException("CreateFeature",e);
+    		}
+    	}
     	static 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();
+    		}
+    	}
     	static String scapeString(String str){
     		return str.replace("'", "''");
+    	}
+    }

     import com.iver.cit.gvsig.fmap.drivers.WKBParser2;
     public class H2FeatureCollection extends AbstractJDBCDataFeatureCollection {
     	protected IFeatureType featureType;
     	protected DBFeatureType featureType;
     	protected String filter;
     	protected String totalFilter;
     	protected H2Store store;
-...
     	private String sqlCount;
     	private String totalOrder;
     	H2FeatureCollection(H2Store store,IFeatureType type, String filter, String order) {
     	H2FeatureCollection(H2Store store,DBFeatureType type, String filter, String order) {
     		this.store=store;
     		this.featureType=type;
     		this.filter=filter;
-...
     	protected class H2Iterator implements Iterator{
     		private ResultSet rs;
     		private JDBCStore store;
     		private IFeatureType featureType;
     		private H2Store store;
     		private DBFeatureType featureType;
     		public H2Iterator(JDBCStore store,IFeatureType featureType ,ResultSet rs){
     		public H2Iterator(H2Store store,DBFeatureType featureType ,ResultSet rs){
     			this.rs = rs;
     			this.store = store;
     			this.featureType = featureType;
-...
     				IFeature feature=null;
     				try {
     					if(rs.next()){
     						feature = H2Utils.createFeature(this.store, this.rs, this.featureType);
     						feature = this.store.createFeatureFromResulset(this.rs, this.featureType);
     					} else {
     						rs.close();
     						rs.getStatement().close();

     	protected class H2Iterator implements Iterator{
     		private Iterator dbIter;
     		private Iterator mIter;
     		public H2Iterator(JDBCStore store, ResultSet rs, DBFeatureType featureType,FeatureManager fm){
     		public H2Iterator(H2Store store, ResultSet rs, DBFeatureType featureType,FeatureManager fm){
     			this.dbIter = new H2IteratorDB(store,rs,featureType,fm);
     			this.mIter = new H2IteratorMemory(featureType,fm);
+    		}
-...
     		private boolean nextChecked=false;
     		private IFeature feature;
     		private ResultSet rs;
     		private JDBCStore store;
     		private H2Store store;
     		private DBFeatureType featureType;
     		private boolean rsEOF=false;
     		private FeatureManager featureManager;
     		public H2IteratorDB(JDBCStore store, ResultSet rs, DBFeatureType featureType, FeatureManager featureManager){
     		public H2IteratorDB(H2Store store, ResultSet rs, DBFeatureType featureType, FeatureManager featureManager){
     			this.store = store;
     			this.rs = rs;
     			this.featureType = featureType;
-...
     			IFeature feature=null;
     			try {
     				if(rs.next()){
     					feature=H2Utils.createFeature(this.store, this.rs, featureType);
     					feature=this.store.createFeatureFromResulset(this.rs, featureType);
+    				}
     			} catch (java.sql.SQLException e) {
     				throw new RuntimeException(

     		private boolean nextChecked=false;
     		private IFeature feature;
     		private ResultSet rs;
     		private JDBCStore store;
     		private H2Store store;
     		private DBFeatureType featureType;
     		private boolean rsEOF=false;
     		public H2Iterator(JDBCStore store, ResultSet rs, DBFeatureType featureType){
     		public H2Iterator(H2Store store, ResultSet rs, DBFeatureType featureType){
     			this.store = store;
     			this.rs = rs;
     			this.featureType = featureType;
-...
     			IFeature feature=null;
     			try {
     				if(rs.next()){
     					feature=H2Utils.createFeature(this.store, this.rs, featureType);
     					feature=this.store.createFeatureFromResulset(this.rs, featureType);
+    				}
     			} catch (java.sql.SQLException e) {
     				throw new RuntimeException(

     import org.gvsig.data.datastores.vectorial.db.DBAttributeDescriptor;
     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.JDBCFeature;
     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.JDBCTypes;
-...
     	DBFeatureType featureType;
     	boolean bCreateTable=false;
     	private String toEncode;
     	H2Store store;
     	JDBCStore store;
     	H2StoreParameters parameters;
     	private PreparedStatement insertSt;
-...
+    	}
     	public void init(IFeatureStore store) {
     		this.store = (H2Store)store;
     		H2Store h2Store = (H2Store)store;
     		this.store = h2Store;
     		this.parameters=(H2StoreParameters)store.getParameters();
     		this.featureType = (DBFeatureType)this.store.getDefaultFeatureType();
     		conex = this.store.getConnection();
     		conex = h2Store.getConnection();
+    	}
     	public void postProcess() throws OpenException, WriteException {
-...
     				System.out.println("sqlCreate =" + sqlCreate);
     				st.execute(sqlCreate);
     //				conex.commit();
+    			}
     //			fieldManager = new JdbcFieldManager(((ConnectionJDBC)conex).getConnection(), lyrDef.getTableName());
     		} catch (SQLException e) {
     			e.printStackTrace();
     //			throw new InitializeWriterException(getName(),e);
+    		}
     //        ResultSet rsAux;
     //		try {
     ////				conex.setAutoCommit(false);
     ////			alterTable();
     //
     ////			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.
     ////	        setEncoding(serverEncoding);
     //		} catch (SQLException e) {
     //			throw new InitializeWriterException("H2",e);
     //		}
+    	}
     	public void deleteFeature(IFeature feature) throws WriteException {
     		Statement st;
     		String sqlDelete = getSqlDeleteFeature(featureType, feature);
     		String sqlDelete = getSqlDeleteFeature(featureType, (JDBCFeature)feature);
     		System.out.println("sql = " + sqlDelete);
     		try {
     			st = this.conex.createStatement();
-...
+    	}
     	public String getSqlDeleteFeature(DBFeatureType dbFeatureType, IFeature feature) {
     	public String getSqlDeleteFeature(DBFeatureType dbFeatureType, JDBCFeature feature) {
     		StringBuffer sqlBuf = new StringBuffer("DELETE FROM "
     				+ this.parameters.tableID() + " WHERE ");
     		String sql = null;
     		sqlBuf.append(H2Utils.getFilterForID(dbFeatureType, feature));
     		sqlBuf.append(((JDBCFeature)feature).getFilterForID());
     		sql = sqlBuf.toString();
     		return sql;

     package org.gvsig.data.datastores.vectorial.db.jdbc.h2;
     import org.gvsig.data.datastores.vectorial.db.DBFeatureType;
     import org.gvsig.data.datastores.vectorial.db.jdbc.AbstractJDBCDataFeatureCollectionWithFeatureID;
     import org.gvsig.data.datastores.vectorial.db.jdbc.JDBCStore;
     import org.gvsig.data.exception.ReadException;
-...
     public class H2FeatureCollectionWithFeatureID extends AbstractJDBCDataFeatureCollectionWithFeatureID {
     	H2FeatureCollectionWithFeatureID(FeatureManager fm,H2Store store,IFeatureType type, String filter,String order) throws ReadException {
     	H2FeatureCollectionWithFeatureID(FeatureManager fm,JDBCStore store,IFeatureType type, String filter,String order) throws ReadException {
     		init(fm, store, type,filter, order);
+    	}
     	public IFeatureCollection newBaseDataFeatureCollection(JDBCStore store, IFeatureType featureType, String filter, String order) {
     		return new H2FeatureCollection((H2Store)store,this.featureType,filter,order);
     		return new H2FeatureCollection((H2Store)store,(DBFeatureType)this.featureType,filter,order);
+    	}
+    }

     import java.lang.ref.WeakReference;
     import java.sql.Connection;
     import java.sql.ResultSet;
     import java.sql.Statement;
     import java.util.ArrayList;
     import java.util.List;
     import java.sql.SQLException;
     import java.util.Locale;
     import org.gvsig.data.IDataCollection;
-...
     import org.gvsig.data.datastores.vectorial.db.DBFeatureType;
     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.WKBParser2;
     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.gvsig.metadata.IMetadataManager;
     import org.gvsig.metadata.MetadataManager;
     import com.iver.cit.gvsig.fmap.core.IGeometry;
     public class H2Store extends JDBCStore{
     	public static final String CONNECTION_STRING = "h2";
     	public static String DATASTORE_NAME = "H2Store";
     	protected static Locale ukLocale = new Locale("en", "UK"); // English, UK version
         public DBFeatureType featureType;
     	protected IMetadata metadata;
     	private static WKBParser2 wkbParser = new WKBParser2();
     	public H2StoreParameters getParametersH2(){
     	protected static Locale ukLocale = new Locale("en", "UK"); // English, UK version
         public H2StoreParameters getParametersH2(){
     		return (H2StoreParameters)this.parameters;
+    	}
-...
     		IFeatureCollection coll;
     		if (featureManager == null){
     			coll=new H2FeatureCollection(this,type,filter,order);
     			coll=new H2FeatureCollection(this,(DBFeatureType)type,filter,order);
     		}else{
     			if ((order != null && order != "")){
     				coll=new H2FeatureCollectionWithFeatureID(featureManager,this,type,filter,order);
-...
     		return coll;
+    	}
     	public IFeature getFeatureByID(IFeatureID id) throws ReadException {
     		return getFeatureByID(featureType,((H2FeatureID)id).getKey());
+    	}
     	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 "+ H2Utils.getFilterForID(this.featureType, featureKey);
     			rs=st.executeQuery(sql);
     			if (rs.isLast()) {
     				return null;
     			}else{
     				if(rs.next()){
     					return H2Utils.createFeature(this, rs, this.featureType);
+    				}
+    			}
     		} catch (java.sql.SQLException e) {
     			e.printStackTrace();
     			throw new ReadException(DATASTORE_NAME, e);
     		} finally{
     			if (rs != null)
     				try {
     					rs.close();
     				} catch (java.sql.SQLException e) {
     					// TODO ?????
     					e.printStackTrace();
+    				}
+    		}
     		return null;
+    	}
     	protected Connection getConnection(){
     		// FIXME: OJO REsource manager
     		return this.connection;
-...
     		return writer;
+    	}
     	public IDataExplorer getExplorer() {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     	public IMetadata getMetadata() {
     		if (metadata==null){
     			IMetadataManager manager=MetadataManager.getManager();
     			metadata=manager.create(DATASTORE_NAME);
     			//TODO: Apadir los meteadatos
     			IMetadata tmp=super.getMetadata();
     			return tmp;
     		}else{
     			return super.getMetadata();
+    		}
     		return metadata;
+    	}
     	public IFeatureType getDefaultFeatureType() {
     		// TODO Auto-generated method stub
     		return this.featureType;
+    	}
     	static String getConnectionResourceID(String dbUrl,String dbUser){
     		return H2Store.CONNECTION_STRING+";"+dbUrl+";"+dbUser;
     	public Object getDefaultLabelingStrategy() {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     	protected void loadValueFromResulset(ResultSet rs, IFeature feature, IFeatureAttributeDescriptor attr) throws ReadException {
     		IGeometry geom;
     		String name = attr.getName();
     		try{
     			if (attr.getDataType().equals(IFeatureAttributeDescriptor.TYPE_GEOMETRY)) {
     				byte[] data = rs.getBytes(name);
     	public Object getDefaultLegend() {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     				if (data == null) {
     					geom = null;
     				} else{
     					geom = wkbParser.parse(data);
+    				}
     	//			feature.setDefaultGeometry(geom);
     				feature.setGeometry(name,geom);
     			} else {
     				feature.set(name, rs.getObject(name));
+    			}
     		} catch (SQLException e) {
     			throw new ReadException(this.getName(),e);
+    		}
     	public List getFeatureTypes() {
     		ArrayList list = new ArrayList();
     		list.add(this.featureType);
     		return list;
+    	}
     	public boolean isWithDefaultLegend() {
     		// TODO Auto-generated method stub
     		return false;
     	protected IFeature newFeatureInstance(DBFeatureType featureType, Object[] pk) {
     		return new H2Feature(featureType,this,pk);
+    	}
     	public IDataExplorer getExplorer() {
     		// TODO Auto-generated method stub
     		return null;
     	IFeature createFeatureFromResulset(ResultSet rs, DBFeatureType featureType2) throws ReadException {
     		return this.createFeature(rs, featureType2);
+    	}
+    }

     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.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.gvsig.metadata.IMetadataManager;
     import org.gvsig.metadata.MetadataManager;
     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
         private DBFeatureType featureType;
     	protected IMetadata metadata;
     	PostgresqlBinStoreParameters getParametersPostgresql(){
         PostgresqlBinStoreParameters getParametersPostgresql(){
     		return (PostgresqlBinStoreParameters)this.parameters;
+    	}
-...
     		ResultSet rs=null;
     		try{
     			this.open();
     			Statement st=this.getConnection().createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
     			String sql = this.getSqlSelectPart() + " WHERE "+ PostgresqlBinStoreUtils.getFliterForID(this.featureType, featureKey);
     			rs=st.executeQuery(sql);
     			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 PostgresqlBinStoreUtils.createFeature(this, rs, this.featureType);
     					return this.createFeature(rs, this.featureType);
+    				}
+    			}
-...
     		return null;
+    	}
     	public IMetadata getMetadata() {
     		if (metadata==null){
     			IMetadataManager manager=MetadataManager.getManager();
     			metadata=manager.create(DATASTORE_NAME);
     			//TODO: Apadir los meteadatos
+    		}
     		return metadata;
+    	}
     	public IDataExplorer getExplorer() {
     		// TODO Auto-generated method stub
     		return null;
-...
     //		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);
+    	}
+    }

     	private static int cursorCount=0;
     	private static String baseCursorName=null;
     	static IFeature createFeatureFromBinaryCursor(JDBCStore store, ResultSet rs, DBFeatureType featureType) throws ReadException {
     		PostgresqlBinFeature feature=null;
     		Object[] pk;
     		try {
     			pk = getPkFromResulsetBinary(rs, featureType);
     			feature=new PostgresqlBinFeature(featureType,store,pk);
     			Iterator iter = featureType.iterator();
     			IGeometry geom = null;
     			while (iter.hasNext()) {
     				JDBCAttributeDescriptor fad=(JDBCAttributeDescriptor)iter.next();
     				feature.set(fad.getName(), getFieldValueFromBinaryCursor(rs, fad));
+    			}
     			return feature;
     		} catch (java.sql.SQLException e) {
     			throw new ReadException("CreateFeature",e);
+    		}
+    	}
     	static Connection getConnection(String dbUrl, String dbUser, String dbPass) throws InitializeException {
     		//TODO: Aqu? habria que implementar la llamada
     		//      al Resource Manager para comprobar si ya hay
-...
+    	}
     	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);
     			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:
     				if (attrDescriptor.getDataType() == IFeatureAttributeDescriptor.TYPE_GEOMETRY){
     					if (byteBuf == null)
     						return null;
     					return wkbParser.parse(byteBuf);
+    				}
     				return null;
+    			}
+    		}
+    	}
     	static Object[] getPkFromResulsetBinary(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] = getFieldValueFromBinaryCursor(
     					rs,
     					(JDBCAttributeDescriptor)featureType.get(
     							featureType.getFieldIndex(fieldsId[i])
+    							)
     				);
+    		}
     		return result;
+    	}
     	static IFeature createFeature(JDBCStore store,ResultSet rs,DBFeatureType featureType) throws ReadException{
     		JDBCFeature feature=null;
     		Object[] pk;
     		try {
     			pk = getPkFromResulset(rs, featureType);
     			feature=new PostgresqlBinFeature(featureType,store,pk);
     			Iterator iter = featureType.iterator();
     			IGeometry geom = null;
     			while (iter.hasNext()) {
     				IFeatureAttributeDescriptor fad=(IFeatureAttributeDescriptor)iter.next();
     				if (fad.getDataType().equals(IFeatureAttributeDescriptor.TYPE_GEOMETRY)) {
     					byte[] data = rs.getBytes(fad.getName());
     					if (data == null) {
     						geom = null;
     					} else{
     						geom = wkbParser.parse(data);
+    					}
     					feature.setGeometry(fad.getName(),geom);
     				} else {
     					feature.set(fad.getName(), rs.getObject(fad.getName()));
+    				}
+    			}
     			return feature;
     		} catch (java.sql.SQLException e) {
     			throw new ReadException("CreateFeature",e);
+    		}
+    	}
     	static String addLimitsToSQL(String aSql,int fetchSize,int page){
     		return aSql+ " limit " + fetchSize + " offset " + (fetchSize*page);
+    	}
-...
+    	}
     	static String getFliterForID(DBFeatureType featureType, Object[] featureKey) {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     	protected static String getFliterForID(DBFeatureType fType, IFeature feature){
     		return getFliterForID(fType, getPkFromFeature(feature,fType));
+    	}
     	protected static 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 static Object[] getPkFromFeature(IFeature feature, DBFeatureType featureType){
     		String[] fieldsId = featureType.getFieldsId();
     		Object[] result = new Object[fieldsId.length];
     		for (int i=0;i<fieldsId.length;i++){
     			result[i] = feature.get(fieldsId[i]);
+    		}
     		return result;
+    	}
     	static String getJDBCUrl(String host, String db, String port) {
     		String url;
     		url = "jdbc:postgresql://"+host+":" + port +"/"+db;

Application: gvSIG desktop

Revision 20058