/ - Diff - gvSIG data provider for PostgreSQL - gvSIG

trunk/org.gvsig.postgresql/org.gvsig.postgresql.provider/src/main/java/org/gvsig/postgresql/dal/PostgreSQLNewStoreParameters.java
56	56	return this.helper.getUseSSL();
57	57	}
58	58
	59	@Override
	60	public int getMaxIdle() {
	61	return this.helper.getMaxIdle();
	62	}
	63
59	64	public void setUseSSL(boolean v) {
60	65	this.helper.setUseSSL(v);
61	66	}

trunk/org.gvsig.postgresql/org.gvsig.postgresql.provider/src/main/java/org/gvsig/postgresql/dal/PostgreSQLServerExplorerParameters.java
66	66	return this.helper.getUseSSL();
67	67	}
68	68
	69	@Override
	70	public int getMaxIdle() {
	71	return this.helper.getMaxIdle();
	72	}
	73
69	74	public void setUseSSL(boolean v) {
70	75	this.helper.setUseSSL(v);
71	76	}

     import java.util.ArrayList;
     import java.util.List;
     import org.apache.commons.dbcp.BasicDataSource;
     import org.apache.commons.dbcp.BasicDataSourceFactory;
     import org.apache.commons.lang3.BooleanUtils;
     import org.apache.commons.lang3.StringUtils;
     import org.gvsig.fmap.dal.DataTypes;
-...
     import org.gvsig.fmap.dal.store.jdbc2.OperationsFactory;
     import org.gvsig.fmap.dal.store.jdbc2.spi.JDBCHelperBase;
     import org.gvsig.fmap.dal.store.jdbc2.spi.JDBCSQLBuilderBase;
     import org.gvsig.fmap.dal.store.jdbc2.spi.JDBCSRSsBase;
     import org.gvsig.fmap.dal.store.jdbc2.spi.SRSSolverBase;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.aggregate.MultiLine;
     import org.gvsig.fmap.geom.aggregate.MultiPoint;
-...
                 if (this.dataSource == null) {
                     this.dataSource = this.createDataSource();
+                }
                 Connection conn = this.dataSource.getConnection();
                 if( logger.isDebugEnabled() ) {
                     logger.debug("getConnection:\n" + getStatusInformation());
+                }
                 Connection conn;
                 try {
                     conn = this.dataSource.getConnection();
                 } catch(Throwable ex) {
                     logger.debug("Error getting connection from pool.",ex);
                     throw ex;
+                }
                 if( logger.isDebugEnabled() ) {
                     logger.debug("Created connection: {}\n  NumActive: {}\n  NumIdle: {}",
                         new Object[] {
                             conn.hashCode(),
                             this.dataSource.getNumActive(),
                             this.dataSource.getNumIdle()
+                        }
                     );
+                }
                 return conn;
+            }
             public void closeConnection(Connection connection) {
                 if( connection != null ) {
                     int connectionId = connection.hashCode();
                     try {
                         connection.close();
                     } catch(Throwable ex) {
                         logger.warn("Can't close connection.", ex);
+                    }
                     if( logger.isDebugEnabled() ) {
                         Boolean isClosed;
                         try {
                             isClosed = connection.isClosed();
                         } catch(Throwable th) {
                             isClosed = null;
+                        }
                         logger.debug("Closed connection: {}\n  isClosed: {}\n  NumActive: {}\n  NumIdle: {}",
                             new Object[] {
                                 connectionId,
                                 isClosed,
                                 this.dataSource.getNumActive(),
                                 this.dataSource.getNumIdle()
+                            }
                         );
+                    }
                } else if( logger.isDebugEnabled() ) {
                    logger.debug("Close connection: null");
+               }
+            }
             public String getStatusInformation() {
                 StringBuilder builder = new StringBuilder();
                 builder.append("BasicDataSource pool status:\n");
                 builder.append("  Connection URL: '").append(this.dataSource.getUrl()).append("'\n");
                 if( this.dataSource.getInitialSize()>0 ) {
                     builder.append("  InitialSize: ").append(this.dataSource.getInitialSize()).append(" (The initial number of connections that are created when the pool is started)\n");
+                }
                 if( this.dataSource.isPoolPreparedStatements() ) {
                     builder.append("  PoolPreparedStatements: ").append(this.dataSource.isPoolPreparedStatements()).append("\n");
                     builder.append("  MaxOpenPreparedStatements: ").append(this.dataSource.getMaxOpenPreparedStatements()).append(" (The maximum number of open statements that can be allocated from the statement pool at the same time, or non-positive for no limit)\n");
+                }
                 builder.append("  MaxActive: ").append(this.dataSource.getMaxActive()).append(" (The maximum number of active connections that can be allocated from this pool at the same time)\n");
                 builder.append("  MaxIdle: ").append(this.dataSource.getMaxIdle()).append(" (The maximum number of connections that can remain idle in the pool)\n");
                 builder.append("  NumActive:").append(this.dataSource.getNumActive()).append(" (the current number of active connections)\n");
                 builder.append("  NumIdle:").append(this.dataSource.getNumIdle()).append(" (the current number of idle connections)\n");
                 return builder.toString();
+            }
             private BasicDataSource createDataSource() throws SQLException {
                 if (!this.isRegistered()) {
-...
                 PostgreSQLConnectionParameters params = connectionParameters;
                 BasicDataSource ds = new BasicDataSource();
                 ds.setMaxIdle(params.getMaxIdle());
                 ds.setDriverClassName(params.getJDBCDriverClassName());
                 if( params.getUseSSL() ) {
                     String s = BooleanUtils.toStringTrueFalse(params.getUseSSL());
-...
         public PostgreSQLHelper(JDBCConnectionParameters connectionParameters) {
             super(connectionParameters);
             this.srss = new JDBCSRSsBase(this);
             this.srssolver = new SRSSolverBase(this);
+        }
         @Override
-...
                 throw new AccessResourceException(PostgreSQLLibrary.NAME, ex);
+            }
+        }
         @Override
         public void closeConnection(Connection connection) {
              this.connectionProvider.closeConnection(connection);
+        }
         @Override
         public PostgreSQLConnectionParameters getConnectionParameters() {
             return (PostgreSQLConnectionParameters) super.getConnectionParameters();

     import org.gvsig.fmap.dal.store.jdbc2.JDBCHelper;
     import org.gvsig.fmap.dal.store.jdbc2.JDBCUtils;
     import org.gvsig.fmap.dal.store.jdbc2.spi.JDBCSQLBuilderBase;
     import org.gvsig.fmap.dal.store.jdbc2.spi.SRSSolver;
     import org.gvsig.fmap.dal.store.jdbc2.spi.operations.FetchFeatureTypeOperation;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.GeometryLocator;
-...
                     attr.setGeometryType(gt);
+                }
                 if( !StringUtils.isEmpty(srsid) ) {
                     attr.setSRS(this.helper.getProjectionFromDatabaseCode(srsid));
                     SRSSolver srssolver = this.helper.getSRSSolver();
                     attr.setSRS(srssolver.getProjection(this.getConnection(),srsid));
+                }
             } catch (Exception ex) {
                 logger.debug("Can't get geometry type and srs from column '"+attr.getName()+"'.",ex);

trunk/org.gvsig.postgresql/org.gvsig.postgresql.provider/src/main/java/org/gvsig/postgresql/dal/PostgreSQLStoreParameters.java
52	52	return this.helper.getUseSSL();
53	53	}
54	54
	55	@Override
	56	public int getMaxIdle() {
	57	return this.helper.getMaxIdle();
	58	}
	59
55	60	public void setUseSSL(boolean v) {
56	61	this.helper.setUseSSL(v);
57	62	}

     public interface PostgreSQLConnectionParameters extends JDBCConnectionParameters, DBParameters {
     	public static final String USESSL_PARAMTER_NAME = "UseSSL";
     	public static final String MAXIDLE_PARAMTER_NAME = "maxIdle";
     	public boolean getUseSSL();
     	public boolean getUseSSL();
         public int getMaxIdle();
+    }

             ((DataParameters)this.parameters).setDynValue(name,value);
+        }
         public int getMaxIdle() {
             return (int) this.getDynValue(PostgreSQLConnectionParameters.MAXIDLE_PARAMTER_NAME);
+        }
         public boolean getUseSSL() {
             return (boolean) this.getDynValue(PostgreSQLConnectionParameters.USESSL_PARAMTER_NAME);

               defaultValue="false" group="Basic">
               <description>Use SSL connetion</description>
             </field>
             <field name="maxIdle" type="integer" mandatory="false"
               defaultValue="8" group="Advanced">
               <description>The maximum number of connections that can remail idle in the pool.</description>
             </field>
           </fields>
         </class>

Application: gvSIG desktop » gvSIG data provider for PostgreSQL

Revision 433