Application: gvSIG desktop

		fc.dispose();

		fc.dispose();

		fc.dispose();

		fc.dispose();

		fc.dispose();

		fc.dispose();

		fc.dispose();

		fc.dispose();

		fc.dispose();

		fc.dispose();

		fc.dispose();

		fc.dispose();

		fc.dispose();

		fc.dispose();

		fc.dispose();

		fc.dispose();

		fc.dispose();

import org.gvsig.data.exception.OpenException;

import org.gvsig.data.exception.WriteException;

import org.gvsig.data.vectorial.Feature;

import org.gvsig.data.vectorial.IFeature;

import org.gvsig.data.vectorial.IFeatureAttributeDescriptor;

	public void test__sqlMode(){

		Register.selfRegister();

		DataManager manager = DataManager.getManager();

		PostgresqlStoreParameters dparam =

			(PostgresqlStoreParameters)manager.createDataStoreParameters(DS_NAME);

		dparam.setHost(SERVER_IP);

		dparam.setPort(SERVER_PORT);

		dparam.setUser(SERVER_USER);

		dparam.setPassw(SERVER_PASWD);

		dparam.setSchema(SERVER_SCHEMA);

		dparam.setDb(SERVER_DBNAME);

//		dparam.setTableName("prueba");

		dparam.setSqlSoure("Select * from "+ SERVER_SCHEMA+".prueba");

		dparam.setFieldId(new String[] {"gid"});

		dparam.setFields(new String[] {"*"});

		dparam.setDefaultGeometryField("the_geom");

		storeTest(dparam, null, null, false);

		Exception exc = null;

		IFeatureStore fs=null;

		try {

			fs = (IFeatureStore)manager.createDataStore(dparam);

		} catch (InitializeException e) {

			e.printStackTrace();

			fail("Exception:" + e);

		}

		assertNotNull("Can't create Feature Store", fs);

		try {

			fs.open();

		} catch (OpenException e2) {

			e2.printStackTrace();

			fail();

		}

		Iterator it;

		IFeatureCollection fc =null;

		try {

			fc = (IFeatureCollection)fs.getDataCollection();

		} catch (ReadException e1) {

			e1.printStackTrace();

			fail();

		}

		assertEquals(9, fc.size());

		fc.dispose();

		assertFalse("Edition allowed in sqlSource mode", fs.isEditable());

		try {

			fs.startEditing();

		} catch (ReadException e1) {

			exc=e1;

		}

		assertNotNull("Edition allowed in sqlSource mode",exc);

		exc=null;

		try {

			fc = (IFeatureCollection)fs.getDataCollection(null,"NOMBRE like 'B%'",null);

		} catch (ReadException e1) {

			exc=e1;

		}

		assertNotNull("Filter allowed in sqlSource mode",exc);

		exc=null;

		try {

			fc = (IFeatureCollection)fs.getDataCollection(null,null,"NOMBRE");

		} catch (ReadException e1) {

			exc=e1;

		}

		assertNotNull("Order allowed in sqlSource mode",exc);

		try {

			fs.close();

		} catch (CloseException e) {

			e.printStackTrace();

			fail("Exception:" + e);

		}

	}

	public void test2(){

		Register.selfRegister();

		DataManager manager = DataManager.getManager();

		PostgresqlStoreParameters dparam =

			(PostgresqlStoreParameters)manager.createDataStoreParameters(DS_NAME);

		dparam.setHost(SERVER_IP);

		dparam.setPort(SERVER_PORT);

		dparam.setUser(SERVER_USER);

		dparam.setPassw(SERVER_PASWD);

		dparam.setSchema(SERVER_SCHEMA);

		dparam.setDb(SERVER_DBNAME);

		dparam.setTableName("prueba");

		dparam.setFieldId(new String[] {"gid"});

		dparam.setFields(new String[] {"*"});

		dparam.setDefaultGeometryField("the_geom");

//		storeTest(dparam, null, null, true);

		storeTest(dparam, null, null, false);

		IFeatureStore fs=null;

		try {

			fs = (IFeatureStore)manager.createDataStore(dparam);

		} catch (InitializeException e) {

			e.printStackTrace();

			fail("Exception:" + e);

		}

		assertNotNull("Can't create Feature Store", fs);

		try {

			fs.open();

		} catch (OpenException e2) {

			e2.printStackTrace();

			fail();

		}

		Iterator it;

		IFeatureCollection fc =null;

		Comparable v1,v2;

		IFeature feature,pfeature;

		long count;

		try {

			fc = (IFeatureCollection)fs.getDataCollection();

		} catch (ReadException e1) {

			e1.printStackTrace();

			fail();

		}

		assertEquals(9, fc.size());

		fc.dispose();

		try {

			fc = (IFeatureCollection)fs.getDataCollection(null,"lower(nombre) like 'b%'",null);

		} catch (ReadException e1) {

			e1.printStackTrace();

			fail();

		}

		assertEquals(2, fc.size());

		it = fc.iterator();

		count=0;

		while (it.hasNext()){

			feature = (IFeature)it.next();

			assertTrue("Filter error",feature.getString("nombre").toLowerCase().startsWith("b"));

			count++;

		}

		assertEquals("Iteration error",2,count);

		fc.dispose();

		try {

			fc = (IFeatureCollection)fs.getDataCollection(null,null,"nombre ASC");

		} catch (ReadException e1) {

			e1.printStackTrace();

			fail();

		}

		assertEquals(9, fc.size());

		it = fc.iterator();

		count=0;

		pfeature = (IFeature)it.next();

		count++;

		while (it.hasNext()){

			feature = (IFeature)it.next();

			v1 = (Comparable)pfeature.get("nombre");

			v2 = (Comparable)feature.get("nombre");

			pfeature=feature;

			assertTrue("Short error", (v1.compareTo(v1) <= 0));

			count++;

		}

		assertEquals("Iteration error",9,count);

		fc.dispose();

		try {

			fc = (IFeatureCollection)fs.getDataCollection(null,null,"nombre DESC");

		} catch (ReadException e1) {

			e1.printStackTrace();

			fail();

		}

		assertEquals(9, fc.size());

		it = fc.iterator();

		count=0;

		pfeature = (IFeature)it.next();

		count++;

		while (it.hasNext()){

			feature = (IFeature)it.next();

			v1 = (Comparable)pfeature.get("nombre");

			v2 = (Comparable)feature.get("nombre");

			pfeature=feature;

			assertTrue("Short error", (v1.compareTo(v1) >= 0));

			count++;

		}

		assertEquals("Iteration error",9,count);

		fc.dispose();

		try {

			fc = (IFeatureCollection)fs.getDataCollection(null,"lower(nombre) like 'b%'","NOMBRE");

		} catch (ReadException e1) {

			e1.printStackTrace();

			fail();

		}

		assertEquals(2, fc.size());

		it = fc.iterator();

		count=0;

		pfeature = (IFeature)it.next();

		assertTrue(pfeature.getString("nombre").toLowerCase().startsWith("b"));

		count++;

		while (it.hasNext()){

			feature = (IFeature)it.next();

			assertTrue("Filter error",feature.getString("nombre").toLowerCase().startsWith("b"));

			v1 = (Comparable)pfeature.get("nombre");

			v2 = (Comparable)feature.get("nombre");

			pfeature=feature;

			assertTrue("Short error", (v1.compareTo(v1) <= 0));

			count++;

		}

		assertEquals("Iteration error",2,count);

		fc.dispose();

		try {

			fc = (IFeatureCollection)fs.getDataCollection(null,null,"Tipo,lower(nombre) Desc");

		} catch (ReadException e1) {

			e1.printStackTrace();

			fail();

		}

		assertEquals(9, fc.size());

		it = fc.iterator();

		count=0;

		pfeature = (IFeature)it.next();

		System.out.println(pfeature.getString("nombre"));

		count++;

		while (it.hasNext()){

			feature = (IFeature)it.next();

			v1 = (Comparable)((String)pfeature.get("nombre")).toLowerCase();

			v2 = (Comparable)((String)feature.get("nombre")).toLowerCase();

			pfeature=feature;

			assertTrue("Short error", (v1.compareTo(v2) >= 0));

			System.out.println(pfeature.getString("nombre"));

			count++;

		}

		assertEquals("Iteration error",9,count);

		fc.dispose();

		/// CON  EDICION

//		try {

//			fs.startEditing();

//		} catch (ReadException e1) {

//			e1.printStackTrace();

//			fail();

//		}

//

//

//		IFeature newFeature = fs.createFeature(fs.getDefaultFeatureType());

//		newFeature.set("nombre","BuRjaSOT");

//		newFeature.set("TIPO","MUNICIPIO");

//		fs.insert(newFeature);

//

//

//		try {

//			fc = (IFeatureCollection)fs.getDataCollection();

//		} catch (ReadException e1) {

//			e1.printStackTrace();

//			fail();

//		}

//

//		assertEquals(10, fc.size());

//		fc.dispose();

//

//		try {

//			fc = (IFeatureCollection)fs.getDataCollection(null,"lower(nombre) like 'b%'",null);

//		} catch (ReadException e1) {

//			e1.printStackTrace();

//			fail();

//		}

//

//		assertEquals(3, fc.size());

//

//		it = fc.iterator();

//		count=0;

//		while (it.hasNext()){

//			feature = (IFeature)it.next();

//			assertTrue("Filter error",feature.getString("nombre").toLowerCase().startsWith("b"));

//			count++;

//		}

//		assertEquals("Iteration error",3,count);

//		fc.dispose();

//

//

//		try {

//			fc = (IFeatureCollection)fs.getDataCollection(null,null,"nombre ASC");

//		} catch (ReadException e1) {

//			e1.printStackTrace();

//			fail();

//		}

//		assertEquals(10, fc.size());

//		it = fc.iterator();

//		count=0;

//		pfeature = (IFeature)it.next();

//		count++;

//		while (it.hasNext()){

//			feature = (IFeature)it.next();

//			v1 = (Comparable)pfeature.get("nombre");

//			v2 = (Comparable)feature.get("nombre");

//			pfeature=feature;

//			assertTrue("Short error", (v1.compareTo(v1) <= 0));

//			count++;

//		}

//		assertEquals("Iteration error",10,count);

//		fc.dispose();

//

//

//		try {

//			fc = (IFeatureCollection)fs.getDataCollection(null,null,"nombre DESC");

//		} catch (ReadException e1) {

//			e1.printStackTrace();

//			fail();

//		}

//		assertEquals(10, fc.size());

//		it = fc.iterator();

//

//		count=0;

//		pfeature = (IFeature)it.next();

//		count++;

//		while (it.hasNext()){

//			feature = (IFeature)it.next();

//			v1 = (Comparable)pfeature.get("nombre");

//			v2 = (Comparable)feature.get("nombre");

//			pfeature=feature;

//			assertTrue("Short error", (v1.compareTo(v1) >= 0));

//			count++;

//		}

//		assertEquals("Iteration error",10,count);

//		fc.dispose();

//

//

//		try {

//			fc = (IFeatureCollection)fs.getDataCollection(null,"lower(nombre) like 'b%'","NOMBRE");

//		} catch (ReadException e1) {

//			e1.printStackTrace();

//			fail();

//		}

//

//		assertEquals(3, fc.size());

//

//		it = fc.iterator();

//

//		count=0;

//		pfeature = (IFeature)it.next();

//		assertTrue(pfeature.getString("nombre").toLowerCase().startsWith("b"));

//		count++;

//		while (it.hasNext()){

//			feature = (IFeature)it.next();

//			assertTrue("Filter error",feature.getString("nombre").toLowerCase().startsWith("b"));

//			v1 = (Comparable)pfeature.get("nombre");

//			v2 = (Comparable)feature.get("nombre");

//			pfeature=feature;

//			assertTrue("Short error", (v1.compareTo(v1) <= 0));

//			count++;

//		}

//		assertEquals("Iteration error",3,count);

//		fc.dispose();

//

//

//

//		try {

//			fc = (IFeatureCollection)fs.getDataCollection(null,null,"Tipo,lower(NOMBRE) Desc");

//		} catch (ReadException e1) {

//			e1.printStackTrace();

//			fail();

//		}

//		assertEquals(10, fc.size());

//		it = fc.iterator();

//		count=0;

//		pfeature = (IFeature)it.next();

//		System.out.println(pfeature.getString("nombre"));

//		count++;

//		while (it.hasNext()){

//			feature = (IFeature)it.next();

//			v1 = (Comparable)((String)pfeature.get("nombre")).toLowerCase();

//			v2 = (Comparable)((String)feature.get("nombre")).toLowerCase();

//			pfeature=feature;

//			assertTrue("Short error", (v1.compareTo(v2) >= 0));

//			System.out.println(pfeature.getString("nombre"));

//			count++;

//		}

//		assertEquals("Iteration error",10,count);

//		fc.dispose();

//

//

//		fs.cancelEditing();

//

//

//		//Insertar un elemento

//		try{

//			fs.startEditing();

//		} catch (ReadException e1) {

//			e1.printStackTrace();

//			fail();

//		}

//

//		feature = fs.createDefaultFeature(true);

//		feature.set("id", 90000);

//		feature.set("nombre","BurJASOT");

//		feature.set("tipo", "OTRO");

//		fs.insert(feature);

//

//		try {

//			fs.finishEditing();

//		} catch (WriteException e) {

//			e.printStackTrace();

//			fail("Exception: "+e);

//		} catch (ReadException e) {

//			e.printStackTrace();

//			fail("Exception: "+e);

//		}

//

//

//		try {

//			fc = (IFeatureCollection)fs.getDataCollection(null,null,"lower(nombre) Desc");

//		} catch (ReadException e1) {

//			e1.printStackTrace();

//			fail();

//		}

//		assertEquals(10, fc.size());

//		it = fc.iterator();

//		count=0;

//		pfeature = (IFeature)it.next();

//		System.out.println(pfeature.getString("nombre"));

//		count++;

//		while (it.hasNext()){

//			feature = (IFeature)it.next();

//			v1 = (Comparable)((String)pfeature.get("nombre")).toLowerCase();

//			v2 = (Comparable)((String)feature.get("nombre")).toLowerCase();

//			pfeature=feature;

//			assertTrue("Short error: "+ v1.toString() + " >= " +v2.toString(), (v1.compareTo(v2) >= 0));

//			System.out.println(pfeature.getString("nombre"));

//			count++;

//		}

//		assertEquals("Iteration error",10,count);

//		fc.dispose();

//

//

//

//		//Actualizacion

//		try{

//			fs.startEditing();

//		} catch (ReadException e1) {

//			e1.printStackTrace();

//			fail();

//		}

//

//

//		try {

//			fc = (IFeatureCollection)fs.getDataCollection(null,"lower(nombre) = 'burjasot'",null);

//		} catch (ReadException e1) {

//			e1.printStackTrace();

//			fail();

//		}

//		assertEquals(1, fc.size());

//		Feature old =(Feature)fc.iterator().next();

//		feature = fs.createDefaultFeature(false);

//		it = fs.getDefaultFeatureType().iterator();

//		IFeatureAttributeDescriptor attr;

//		while(it.hasNext()){

//			 attr = (IFeatureAttributeDescriptor)it.next();

////			 if (attr.getDataType() == IFeatureAttributeDescriptor.TYPE_GEOMETRY){

////				 feature.set(attr.getName(), old.get(attr.getName()));

////			 } else {

//				 feature.set(attr.getName(), old.get(attr.getName()));

////			 }

//		}

//		feature.set("NOMBRE", feature.getString("nombre")+"__KK__");

//

//		fs.update(feature, old);

//		try {

//			fs.finishEditing();

//		} catch (WriteException e) {

//			e.printStackTrace();

//			fail("Exception: "+e);

//		} catch (ReadException e) {

//			e.printStackTrace();

//			fail("Exception: "+e);

//		}

//

//		try {

//			fc = (IFeatureCollection)fs.getDataCollection(null,"nombre like '%__KK__'",null);

//		} catch (ReadException e1) {

//			e1.printStackTrace();

//			fail();

//		}

//		assertEquals(1, fc.size());

//		fc.dispose();

//

//

//		//Eliminacion

//		try{

//			fs.startEditing();

//		} catch (ReadException e1) {

//			e1.printStackTrace();

//			fail();

//		}

//

//

//		try {

//			fc = (IFeatureCollection)fs.getDataCollection(null,"nombre like '%__KK__'",null);

//		} catch (ReadException e1) {

//			e1.printStackTrace();

//			fail();

//		}

//		assertEquals(1, fc.size());

//		fs.delete((IFeature)fc.iterator().next());

//		fc.dispose();

//		try {

//			fs.finishEditing();

//		} catch (WriteException e) {

//			e.printStackTrace();

//			fail("Exception: "+e);

//		} catch (ReadException e) {

//			e.printStackTrace();

//			fail("Exception: "+e);

//		}

//

//		try {

//			fc = (IFeatureCollection)fs.getDataCollection();

//		} catch (ReadException e1) {

//			e1.printStackTrace();

//			fail();

//		}

//		assertEquals(9, fc.size());

//		fc.dispose();

		try {

			fs.close();

		} catch (CloseException e) {

			e.printStackTrace();

			fail("Exception:" + e);

		}

	}

		checkModified();

		checkModified();

		PostgresqlIterator dbIter;

			dbIter=new PostgresqlIterator((PostgresqlStore)this.store,this.featureType,this.sql,this.fetchSize);

		return dbIter;

			checkModified();

			checkModified();

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

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.Statement;

import java.util.ConcurrentModificationException;

import java.util.Iterator;

import java.util.NoSuchElementException;

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

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

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

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

import org.gvsig.data.exception.ReadException;

import org.gvsig.data.vectorial.AbstractFeatureCollection;

import org.gvsig.data.vectorial.IFeature;

import org.gvsig.data.vectorial.IFeatureType;

import org.gvsig.data.vectorial.expansionadapter.FeatureManager;

import org.gvsig.data.vectorial.filter.FeatureFilterParser;

import org.gvsig.exceptions.BaseException;

public class PostgresqlFeatureCollectionEditingFiltered extends AbstractJDBCDataFeatureCollection {

	protected DBFeatureType featureType;

	protected String totalFilter;

	protected String filter;

	protected PostgresqlStore store;

	private int numReg=-1;

	private String sql;

	private String sqlCount;

	private String totalOrder;

	private int fetchSize=5000;

	private FeatureManager featureManager;

	private FeatureFilterParser parser;

	PostgresqlFeatureCollectionEditingFiltered(FeatureManager fm,PostgresqlStore store,IFeatureType type,String filter) {

		this.featureManager=fm;

		this.store=store;

		this.featureType=(DBFeatureType)type;

		this.filter = filter;

		this.calculateWhere();

		this.totalOrder = store.getBaseOrder();

		this.sql = this.store.getSqlSelectPart();

		this.sqlCount = "Select count(*) From "+ ((PostgresqlStoreParameters)this.store.getParameters()).tableID();

		if (!isStringEmpty(this.totalFilter)){

			this.sql= this.sql + " Where " + this.totalFilter;

			this.sqlCount= this.sqlCount + " Where " + this.totalFilter;

		}

		if (!isStringEmpty(this.totalOrder)){

			this.sql= this.sql + " Order by " + this.totalOrder;

		}

		if (this.filter!=null)

			parser = new FeatureFilterParser(filter,this.featureType);

	}

	private void calculateWhere(){

		if (isStringEmpty(this.store.getBaseWhereClause())){

			this.totalFilter = this.filter;

		} else {

			this.totalFilter = "(" + this.store.getBaseWhereClause() + ") and " +this.filter;

		}

	}

	private ResultSet getNewResulset(String aSql) throws ReadException{

		this.store.open();

		Connection con = this.store.getCurrentConnection();

		try {

			Statement st = con.createStatement(ResultSet.TYPE_FORWARD_ONLY,ResultSet.CONCUR_READ_ONLY);

			return st.executeQuery(aSql);

		} catch (java.sql.SQLException e) {

			throw new SQLException(aSql,this.store.getName(),e);

		}

	}

	public int size() {

		checkModified();

		if (this.numReg < 0){

			this.numReg =0;

			try{

				Iterator iter = this.iterator();

				while (true){

					iter.next();

					this.numReg++;

				}

			} catch (NoSuchElementException e){

				//Normal condition exit

			}

		}

		return this.numReg;

	}

	public Iterator iterator() {

		checkModified();

		try{

			PostgresIterator dbIter=new PostgresIterator(this.store,this.featureType,this.sql,this.fetchSize,this.featureManager);

			return dbIter;

		} catch (BaseException e){

			throw new RuntimeException(e);

		}

	}

	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{

			this.dbIter = new IteratorDB(store,featureType,sql,fetchSize,featureManager);

			this.mIter = new IteratorMemory(featureType,featureManager);

		}

		public boolean hasNext() {

			return dbIter.hasNext() || mIter.hasNext();

		}

		public Object next() {

			if (dbIter.hasNext()){

				return dbIter.next();

			}

			return mIter.next();

		}

		public void remove() {

			throw new UnsupportedOperationException();

		}

	}

	protected class IteratorDB implements Iterator{

		private boolean nextChecked=false;

		private IFeature feature;

		private ResultSet rs;

		private JDBCStore store;

		private DBFeatureType featureType;

		private boolean rsEOF=false;

		private FeatureManager featureManager;

		private int fetchSize;

		private String sql;

		private int page;

		private int index;

		public IteratorDB(JDBCStore store, DBFeatureType featureType,String sql,int fetchSize, FeatureManager featureManager) throws ReadException{

			this.store = store;

			this.featureType = featureType;

			this.featureManager= featureManager;

			this.fetchSize = fetchSize;

			this.sql = sql;

			this.page = 0;

			this.index = 0;

			this.createResulset();

		}

		public boolean hasNext(){

			checkModified();

			if (nextChecked){

				return this.feature != null;

			}

			IFeature feature=null;

			nextChecked=true;

			while (true){

				if (!rsEOF){

					try {

						if (rs.isLast()){

							if (this.index == this.fetchSize){

								this.index = 0;

								this.page++;

								this.createResulset();

								if (rs.isLast()){

									rsEOF = true;

									rs.close();

									continue;

								}

							} else{

								rsEOF = true;

								rs.close();

								continue;

							}

						} else {

							feature=nextFeature();

							if(featureManager.isDeleted(feature))

								continue;

							this.feature=feature;

							return true;

						}

					} catch (java.sql.SQLException e) {

						throw new RuntimeException(

								new ReadException(this.store.getName(),e)

						);

					} catch (ReadException e) {

						throw new RuntimeException(e);

					}

				}else {

					return false;

				}

			}

		}

		public Object next() {

			checkModified();

			if (!nextChecked){

				hasNext();

			}

			if (this.feature == null)

				throw new NoSuchElementException();

			nextChecked=false;

			IFeature feature = this.feature;

			this.feature = null;

			return feature;

		}

		private IFeature nextFeature() {

			IFeature feature=null;

			try {

				if(rs.next()){

					feature=PostgresqlStoreUtils.createFeature(this.store, this.rs, featureType);

				}

			} catch (java.sql.SQLException e) {

				throw new RuntimeException(

						new ReadException(this.store.getName(),e)

					);

			} catch (ReadException e) {

				throw new RuntimeException(e);

			}

			return feature;

		}

		public void remove() {

			throw new UnsupportedOperationException();

		}

		protected void createResulset() throws ReadException{

			this.store.open();

			String mSql = PostgresqlStoreUtils.addLimitsToSQL(

					this.sql,

					this.fetchSize,

					this.page);

			Connection conn = ((PostgresqlStore)this.store).getCurrentConnection();

			try {

				if (this.rs != null){

					this.rs.close();

				}

				Statement st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY,ResultSet.CONCUR_READ_ONLY);

				this.rs = st.executeQuery(mSql);

			} catch (java.sql.SQLException e) {

				throw new SQLException(mSql,this.store.getName(),e);

			}

		}

	}

	protected class IteratorMemory implements Iterator{

		protected long position=0;

		private boolean nextChecked=false;

		private IFeature feature;

		private FeatureManager featureManager;

		public IteratorMemory(DBFeatureType featureType,FeatureManager featureManager){

			this.featureManager= featureManager;

			position=0;

		}

		public boolean hasNext(){

			checkModified();

			if (nextChecked){

				return this.feature != null;

			}

			IFeature feature=null;

			nextChecked=true;

			while (true){

				if (position<featureManager.getNum()){

					feature=featureManager.getFeature((int)position);

					position++;

				}else{

					this.feature = null;

					return false;

				}

				if(featureManager.isDeleted(feature))

					continue;

				if (filter == null) {

					this.feature=feature;

					return true;

				} else {

					try {

						if (parser.match(feature)){

							this.feature=feature;

							return true;

						}else{

							continue;

						}

					} catch (Exception e) {

						throw new RuntimeException(e);

					}

				}

			}

		}

		public Object next() {

			checkModified();

			if (!nextChecked){

				hasNext();

			}

			if (this.feature == null)

				throw new NoSuchElementException();

			nextChecked=false;

			IFeature feature = this.feature;

			this.feature = null;

			return feature;

		}

		public void remove() {

			throw new UnsupportedOperationException();

		}

	}

	public void dispose() {

		this.store.deleteObserver(this);

		this.store = null;

		this.featureManager = null;

		this.featureType = null;

		this.parser= null;

	}

}

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

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.Statement;

import java.util.ConcurrentModificationException;

import java.util.Iterator;

import java.util.NoSuchElementException;

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

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

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

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

import org.gvsig.data.exception.ReadException;

import org.gvsig.data.vectorial.AbstractFeatureCollection;

import org.gvsig.data.vectorial.IFeature;

import org.gvsig.data.vectorial.IFeatureType;

import org.gvsig.data.vectorial.expansionadapter.FeatureManager;

import org.gvsig.exceptions.BaseException;

public class PostgresqlFeatureCollectionEditing extends AbstractJDBCDataFeatureCollection {

	protected DBFeatureType featureType;

	protected String totalFilter;

	protected PostgresqlStore store;

	private int numReg=-1;

	private String sql;

	private String sqlCount;

	private String totalOrder;

	private int fetchSize=5000;

	private FeatureManager featureManager;

	PostgresqlFeatureCollectionEditing(FeatureManager fm,PostgresqlStore store,IFeatureType type) {

		this.featureManager=fm;

		this.store=store;

		this.featureType=(DBFeatureType)type;

		this.totalFilter =store.getBaseWhereClause();

		this.totalOrder = store.getBaseOrder();

		this.sql = this.store.getSqlSelectPart();

		this.sqlCount = "Select count(*) From "+ ((PostgresqlStoreParameters)this.store.getParameters()).tableID();

		if (!isStringEmpty(this.totalFilter)){

			this.sql= this.sql + " Where " + this.totalFilter;

			this.sqlCount= this.sqlCount + " Where " + this.totalFilter;

		}

		if (!isStringEmpty(this.totalOrder)){

			this.sql= this.sql + " Order by " + this.totalOrder;

		}

	}

	private ResultSet getNewResulset(String aSql) throws ReadException{

		this.store.open();

		Connection conn = this.store.getCurrentConnection();

		try {

			Statement st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY,ResultSet.CONCUR_READ_ONLY);

			return st.executeQuery(aSql);

		} catch (java.sql.SQLException e) {

			throw new SQLException(aSql,this.store.getName(),e);

		}

	}

	public int size() {

		checkModified();

		try {

			if (this.numReg < 0){

				ResultSet r=null;

				r = this.getNewResulset(this.sqlCount);

				try {

					r.next();

					numReg = r.getInt(1);

				} catch (java.sql.SQLException e) {

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

				} finally{

					try {

						r.close();

					} catch (java.sql.SQLException e) {

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

					}

				}

				numReg = numReg+featureManager.getNum();

			}

			return numReg;

		} catch (BaseException e){

			throw new RuntimeException(e);

		}

	}

	public Iterator iterator() {

		checkModified();

		try{

			ResultSet r=null;

			r = this.getNewResulset(this.sql);

			PostgresIterator dbIter=new PostgresIterator(this.store,this.featureType,this.sql,this.fetchSize);

			return dbIter;

		} catch (BaseException e){

			throw new RuntimeException(e);

		}

	}

	protected class PostgresIterator implements Iterator{

		private ResultSet rs;

		private boolean nextChecked=false;

		private IFeature feature;

		private JDBCStore store;

		private DBFeatureType featureType;

		private String sql;

		private int fetchSize;

		private int page;

		private int index;

		private long position;

		private boolean rsEOF=false;

		public PostgresIterator(JDBCStore store, DBFeatureType featureType,String sql,int fetchSize)  throws ReadException{

			this.sql = sql;

			this.store = store;

			this.featureType = featureType;

			this.fetchSize= fetchSize;

			this.page = 0;

			this.index = 0;

			this.createResulset();

		}

		public boolean hasNext(){

			checkModified();

			IFeature feature=null;

			if (nextChecked){

				return feature != null;

			}

			nextChecked=true;

			while (true){

				if (!rsEOF){

					try {

						if (rs.isLast()){

							if (this.index == this.fetchSize){

								this.index = 0;

								this.page++;

								this.createResulset();

								if (rs.isLast()){

									rsEOF = true;

									rs.close();

									continue;

								}

							} else{

								rsEOF = true;

								rs.close();

								continue;

							}

						} else {

							feature=nextFeature();

						}

					} catch (java.sql.SQLException e) {

						throw new RuntimeException(

								new ReadException(this.store.getName(),e)

						);

					} catch (ReadException e) {

						throw new RuntimeException(e);

					}

				}else {

					if (position<featureManager.getNum()){

						feature=featureManager.getFeature((int)position);

					}else{

						this.feature = null;

						return false;

					}

				}

				if(featureManager.isDeleted(feature))

					continue;

				position++;

				this.feature=feature;

				return true;

			}

		}

		public Object next() {

			checkModified();

			if (!nextChecked){

				hasNext();

			}

			if (feature == null)

				throw new NoSuchElementException();

			nextChecked=false;

			return feature;

		}

		private IFeature nextFeature() {

			IFeature feature=null;

			try {

				if(rs.next()){

					feature=PostgresqlStoreUtils.createFeature(this.store, this.rs, featureType);

				}

			} catch (java.sql.SQLException e) {

				throw new RuntimeException(

						new ReadException(this.store.getName(),e)

					);

			} catch (ReadException e) {

				throw new RuntimeException(e);

			}

			return feature;

		}

		protected void createResulset() throws ReadException{

			this.store.open();

			String mSql = PostgresqlStoreUtils.addLimitsToSQL(

					this.sql,

					this.fetchSize,

					this.page);

			Connection conn = ((PostgresqlStore)this.store).getCurrentConnection();

			try {

				if (this.rs != null){

					this.rs.close();

//					this.rs.getStatement().close();

				}

				Statement st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY,ResultSet.CONCUR_READ_ONLY);

//				System.out.println(mSql);

				this.rs = st.executeQuery(mSql);

			} catch (java.sql.SQLException e) {

				throw new SQLException(mSql,this.store.getName(),e);

			}

		}

		public void remove() {

			throw new UnsupportedOperationException();

		}

	}

	public void dispose() {

		this.store.deleteObserver(this);

		this.store = null;

		this.featureManager = null;

		this.featureType = null;

	}

}

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

					coll=new PostgresqlFeatureCollectionEditing(featureManager,this,type);

				} else {

					coll=new PostgresqlFeatureCollectionEditingFiltered(featureManager,this,type,filter);

				}

		checkModified();

		checkModified();

		if (this.numReg < 0){

			this.numReg=0;

			try{

				Iterator iter =this.iterator();

				while (true){