| gvSIG desktop 1

		String sql = "Select current_schema()";

		ResultSet rs = null;

		Statement st = null;

		String schema = null;

		try {

			st = conn.createStatement();

			rs = st.executeQuery(sql);

			rs.next();

			schema = rs.getString(1);

		} catch (java.sql.SQLException e) {

			throw new InitializeException(PostgresqlStore.DATASTORE_NAME, e);

		} finally {

			if (st != null) {

				if (rs != null) {

					try {

						rs.close();

					} catch (java.sql.SQLException e) {

						throw new InitializeException(

								PostgresqlStore.DATASTORE_NAME, e);

					}

				}

				try {

					st.close();

				} catch (java.sql.SQLException e) {

					throw new InitializeException(

							PostgresqlStore.DATASTORE_NAME, e);

				}

			}

		}

		return schema;

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

import org.gvsig.fmap.data.datastores.vectorial.db.jdbc.JDBCExplorerParameter;

public class PostgresqlExplorerParameters extends JDBCExplorerParameter {

	private boolean showInformationDBTables=false;

	public String getUrl() {

		return PostgresqlStoreUtils.getJDBCUrl(this.getHost(), this.getDb(),

				this.getPort());

	}

	public String getDataExplorerName() {

		return PostgresqlExplorer.DATAEXPLORER_NAME;

	}

	public boolean isShowInformationDBTables() {

		return showInformationDBTables;

	}

	public void setShowInformationDBTables(boolean showInformationDBTables) {

		this.showInformationDBTables = showInformationDBTables;

	}

}

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

import java.security.KeyException;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.ArrayList;

import org.gvsig.fmap.data.CloseException;

import org.gvsig.fmap.data.DataException;

import org.gvsig.fmap.data.DataExplorerParameters;

import org.gvsig.fmap.data.DataManager;

import org.gvsig.fmap.data.DataStoreParameters;

import org.gvsig.fmap.data.InitializeException;

import org.gvsig.fmap.data.NewDataStoreParameters;

import org.gvsig.fmap.data.ReadException;

import org.gvsig.fmap.data.ResourceManager;

import org.gvsig.fmap.data.datastores.vectorial.db.DBAttributeDescriptor;

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

import org.gvsig.fmap.data.datastores.vectorial.db.jdbc.JDBCExplorer;

import org.gvsig.fmap.data.vectorial.FeatureAttributeDescriptor;

import org.gvsig.fmap.data.vectorial.FeatureType;

import org.gvsig.fmap.data.vectorial.InitializeWriterException;

import org.gvsig.fmap.data.vectorial.NewFeatureStoreParameters;

public class PostgresqlExplorer extends JDBCExplorer {

	public static String DATAEXPLORER_NAME = "PostgresqlExplorer";

	private String defaultSchema;

	private void appendFieldToCreteSQL(DBAttributeDescriptor attr,StringBuffer sql) throws InitializeException{

		/**

		 * column_name data_type [ DEFAULT default_expr ] [ column_constraint [

		 * ... ] ]

		 *

		 * where column_constraint is:

		 *

		 * [ CONSTRAINT constraint_name ] { NOT NULL | NULL | UNIQUE | PRIMARY

		 * KEY | CHECK (expression) | REFERENCES reftable [ ( refcolumn ) ] [

		 * MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE action ] [ ON

		 * UPDATE action ] } [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY

		 * DEFERRED | INITIALLY IMMEDIATE ]

		 */

		//name

		sql.append(attr.getName());

		sql.append(" ");

		//dataType

		String type =attr.getDataType();

		if (type.equals(FeatureAttributeDescriptor.TYPE_STRING)){

			if (attr.getSize() < 1 || attr.getSize() > 255) {

				sql.append("text");

			} else {

				sql.append("varchar(" + attr.getSize() + ")");

			}

		} else if (type.equals(FeatureAttributeDescriptor.TYPE_BOOLEAN)){

			sql.append("bool");

		} else if (type.equals(FeatureAttributeDescriptor.TYPE_BYTE)){

			sql.append("smallint");

		} else if (type.equals(FeatureAttributeDescriptor.TYPE_DATE)){

			sql.append("date");

		} else if (type.equals(FeatureAttributeDescriptor.TYPE_TIMESTAMP)){

			sql.append("timestamp");

		} else if (type.equals(FeatureAttributeDescriptor.TYPE_TIME)){

			sql.append("time");

		} else if (type.equals(FeatureAttributeDescriptor.TYPE_DOUBLE)){

			sql.append("double precision");

			if (attr.getPrecision() > 0){

				sql.append(" "+ attr.getPrecision());

			}

		} else if (type.equals(FeatureAttributeDescriptor.TYPE_FLOAT)){

			sql.append("real");

		} else if (type.equals(FeatureAttributeDescriptor.TYPE_GEOMETRY)){

			sql.append("geometry");

		} else if (type.equals(FeatureAttributeDescriptor.TYPE_INT)){

			if (attr.isAutoIncrement()){

				sql.append("serial");

			}else{

				sql.append("integer");

			}

		} else if (type.equals(FeatureAttributeDescriptor.TYPE_LONG)){

			if (attr.isAutoIncrement()){

				sql.append("bigserial");

			}else{

				sql.append("bigint");

			}

		} else {

			throw new InitializeException(this.getName(),new Exception("Unsuported type "+type));

		}

		sql.append(" ");

//		//DefeaultValue

//		if (attr.getDefaultValue() != null || (attr.getDefaultValue() == null && attr.isAllowNull() )){

//			sql.append("DEFAULT ? ");

//			sqlParams.add(attr.getDefaultValue());

//

//		}

		//Null

		if (attr.isAllowNull()){

			sql.append("NOT NULL ");

		} else {

			sql.append("NULL ");

		}

		// Primery key

		if (attr.isPrimaryKey()) {

			sql.append("PRIMARY KEY ");

		}

	}

	public DataStoreParameters add(NewFeatureStoreParameters ndsp)

			throws InitializeException, InitializeWriterException {

		Connection conn;

		try {

			conn = this.getConnection();

		} catch (ReadException e1) {

			throw new InitializeException(this.getName(),e1);

		}

		try {

			conn.setAutoCommit(true);

		} catch (SQLException e) {

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

		}

		DataStoreParameters params = this.add(ndsp,conn);

		return params;

	}

	protected DataStoreParameters add(NewFeatureStoreParameters ndsp,Connection conn)

		throws InitializeException, InitializeWriterException {

		/**

		 * CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } ] TABLE table_name (

		 * { column_name data_type [ DEFAULT default_expr ] [ column_constraint

		 * [ ... ] ] | table_constraint | LIKE parent_table [ { INCLUDING |

		 * EXCLUDING } DEFAULTS ] } [, ... ] ) [ INHERITS ( parent_table [, ...

		 * ] ) ] [ WITH OIDS | WITHOUT OIDS ] [ ON COMMIT { PRESERVE ROWS |

		 * DELETE ROWS | DROP } ]

		 *

		 * where column_constraint is:

		 *

		 * [ CONSTRAINT constraint_name ] { NOT NULL | NULL | UNIQUE | PRIMARY

		 * KEY | CHECK (expression) | REFERENCES reftable [ ( refcolumn ) ] [

		 * MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE action ] [ ON

		 * UPDATE action ] } [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY

		 * DEFERRED | INITIALLY IMMEDIATE ]

		 *

		 * and table_constraint is:

		 *

		 * [ CONSTRAINT constraint_name ] { UNIQUE ( column_name [, ... ] ) |

		 * PRIMARY KEY ( column_name [, ... ] ) | CHECK ( expression ) | FOREIGN

		 * KEY ( column_name [, ... ] ) REFERENCES reftable [ ( refcolumn [, ...

		 * ] ) ] [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE

		 * action ] [ ON UPDATE action ] } [ DEFERRABLE | NOT DEFERRABLE ] [

		 * INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

		 */

//		PreparedStatement st=null;

		Statement st=null;

		StringBuffer sql = new StringBuffer();

		if (!ndsp.isValid()){

			//TODO Exception

			throw new InitializeException(this.getName(),new Exception("Parameters not valid"));

		}

		PostgresqlStoreParameters param = (PostgresqlStoreParameters) ndsp

				.getDataStoreParameters();

		DBFeatureType fType = (DBFeatureType)ndsp.getFeatureType();

		sql.append("Create table " + param.tableID() + "(");

		DBAttributeDescriptor attr;

		FeatureAttributeDescriptor[] fads=(FeatureAttributeDescriptor[])fType.toArray(new FeatureAttributeDescriptor[0]);

		for (int j = 0; j < fads.length-1; j++) {

//			appendFieldToCreteSQL(attr, sql,sqlParamas);

			appendFieldToCreteSQL((DBAttributeDescriptor)fads[j], sql);

			sql.append(",");

		}

		attr = (DBAttributeDescriptor)fads[fads.length-1];

		appendFieldToCreteSQL(attr, sql);

		sql.append(")");

		try{

//			st = conn.prepareStatement(sql.toString());

//			for (i=0;i<sqlParamas.size();i++){

//				st.setObject(i+1, sqlParamas.get(i));

//			}

			st = conn.createStatement();

			st.execute(sql.toString());

		} catch (SQLException e) {

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

		} finally{

			if (st != null){

				try {

					st.close();

				} catch (SQLException e) {

					// TODO ???

					e.printStackTrace();

				}

			}

		}

		return param;

	}

	public NewDataStoreParameters createNewDataStoreParameter() {

		return new PostgresqlNewStoreParameter(this.newStoreParamters());

	}

	public void remove(DataStoreParameters dsp) throws ReadException {

		Connection conn = this.getConnection();

		try {

			conn.setAutoCommit(true);

		} catch (SQLException e) {

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

		}

		this.remove(dsp, conn);

	}

	protected void remove(DataStoreParameters dsp,Connection conn) throws ReadException {

		Statement st=null;

		try{

			st = conn.createStatement();

			st.execute("Drop table "

					+ ((PostgresqlStoreParameters) dsp).tableID());

		} catch (SQLException e) {

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

		} finally{

			if (st != null){

				try {

					st.close();

				} catch (SQLException e) {

					// TODO ???

					e.printStackTrace();

				}

			}

		}

	}

	public boolean canCreate() {

		return true;

	}

	public String getName() {

		return DATAEXPLORER_NAME;

	}

	public String getDataStoreName(){

		return PostgresqlStore.DATASTORE_NAME;

	}

	public void init(DataExplorerParameters parameters) throws InitializeException {

		PostgresqlResource tmpResource = new PostgresqlResource(

				(PostgresqlExplorerParameters) parameters);

		PostgresqlResource theResource;

		ResourceManager resMan = ResourceManager.getResourceManager();

		try {

			theResource = (PostgresqlResource) resMan.addResource(tmpResource);

		} catch (DataException e1) {

			throw new InitializeException(this.getName(),e1);

		}

		super.init(parameters,theResource);

		try {

			this.defaultSchema = PostgresqlStoreUtils.getDefaultSchema(this

					.getConnection(), this.parameters.getCatalog());

		} catch (ReadException e) {

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

		}

	}

	private PostgresqlStoreParameters newStoreParamters() {

		DataManager manager = DataManager.getManager();

		PostgresqlStoreParameters param;

		try {

			param = (PostgresqlStoreParameters) manager

					.createDataStoreParameters(getDataStoreName());

		} catch (InitializeException e) {

			// FIXME no deber?a de ocurrir pero... que hacemos???

			return null;

		}

		this.parameters.fillStoreParameters(param);

		return param;

	}

	public DataStoreParameters[] list() throws ReadException {

		return this.list(((PostgresqlExplorerParameters)this.parameters).isShowInformationDBTables());

	}

	public DataStoreParameters[] list(boolean showInformationDBTables) throws ReadException {

		Connection conn = this.getConnection();

		StringBuffer sqlBuf = new StringBuffer();

		String sql;

		sqlBuf

				.append("SELECT TABLE_CATALOG, TABLE_SCHEMA, TABLE_NAME, false as ISVIEW");

		sqlBuf.append("FROM INFORMATION_SCHEMA.TABLES");

		sqlBuf.append(" xxWHERExx ");

		sqlBuf.append(" union ");

		sqlBuf

				.append("SELECT TABLE_CATALOG, TABLE_SCHEMA, TABLE_NAME, true as ISVIEW");

		sqlBuf.append("FROM INFORMATION_SCHEMA.VIEWS");

		sqlBuf.append(" xxWHERExx ");

		if (showInformationDBTables) {

			sql = sqlBuf

					.toString()

					.replaceAll("xxWHERExx",

							"");

		} else {

			sql = sqlBuf

					.toString()

					.replaceAll("xxWHERExx",

							"WHERE TABLE_SCHEMA NOT IN ('information_schema','pg_catalog')");

		}

		ArrayList paramList = new ArrayList();

		PostgresqlStoreParameters param = null;

		ResultSet rs = null;

		Statement st = null;

		try{

			st = conn.createStatement();

			rs = st.executeQuery(sql);

			while (rs.next()){

				param = this.newStoreParamters();

				param.setCatalog(rs.getString(1));

				param.setSchema(rs.getString(2));

				param.setTableName(rs.getString(3));

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

				if (rs.getBoolean(4)) {

					param.setIsView(param.IS_VIEW);

				} else {

					param.setIsView(param.NOT_IS_VIEW);

				}

				paramList.add(param);

			}

		} catch (SQLException e) {

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

		} finally {

			if (st != null) {

				if (rs != null) {

					try {

						rs.close();

					} catch (java.sql.SQLException e) {

						throw new InitializeException(

								PostgresqlStore.DATASTORE_NAME, e);

					}

				}

				try {

					st.close();

				} catch (java.sql.SQLException e) {

					throw new InitializeException(

							PostgresqlStore.DATASTORE_NAME, e);

				}

			}

		}

		return (DataStoreParameters[]) paramList

				.toArray(new PostgresqlStoreParameters[0]);

	}

	public FeatureType[] getFeatureTypes(DataStoreParameters dsp) throws ReadException {

		return new FeatureType[] { PostgresqlStoreUtils.getFeatureType(this

				.getConnection(), (PostgresqlStoreParameters) dsp) };

	}

	public String getDefaultSchema(){

		return this.defaultSchema;

	}

	/* (non-Javadoc)

	 * @see org.gvsig.fmap.data.DataExplorer#dispose()

	 */

	public void dispose() throws DataException {

		ResourceManager resMan = ResourceManager.getResourceManager();

    	try {

			resMan.remove(this.resource);

		} catch (DataException e1) {

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

		} catch (KeyException e) {

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

		}

	}

}

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

import org.gvsig.fmap.data.DataStoreParameters;

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

import org.gvsig.fmap.data.datastores.vectorial.db.DBNewStoreParameter;

public class PostgresqlNewStoreParameter extends DBNewStoreParameter {

	PostgresqlNewStoreParameter(DataStoreParameters dsp) {

		this.init(dsp);

	}

	public PostgresqlStoreParameters getPostgresqlParameters() {

		return (PostgresqlStoreParameters) this.dsparameters;

	}

	public DBFeatureType getDBFeatureType(){

		return (DBFeatureType)this.featureType;

	}

	public String getDataStoreName() {

		return PostgresqlStore.DATASTORE_NAME;

	}

	public boolean isValid() {

		if (!super.isValid()){

			return false;

		}

		if (!(this.dsparameters instanceof PostgresqlStoreParameters)) {

			return false;

		}

		if (this.getDBFeatureType().getFieldsId().length != 1){

			return false;

		}

		return true;

	}

}