Application: gvSIG desktop » gvSIG data provider for PostgreSQL

org.gvsig.postgresql.dal.PostgreSQLLibrary

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="PostgreSQL" namespace="Metadata">

      <extends>

      	<class name="JDBC2" namespace="Metadata"/>

      </extends>

      <description>Metadata of a PostgreSQL store</description>

      <fields>

      </fields>

    </class>

  </classes>

</definitions>  

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="PostgreSQLResourceParameters">

      <extends>

        <class>JDBC2ResourceParameters</class>

      </extends>

      <description>_PostgreSQL_loading_parameters</description>

      <fields>

        <field name="JDBCDriverClass" type="string" mandatory="true"

          defaultValue="org.postgresql.Driver" group="Advanced">

          <description>JDBC Driver class</description>

        </field>

	<field name="port" type="integer" mandatory="false"

          defaultValue="5432" group="Connection">

          <description></description>

        </field>

        <field name="host" type="string" mandatory="false" 

            defaultValue="127.0.0.1" group="Connection">

          <description></description>

        </field>

        <field name="UseSSL" type="boolean" mandatory="false"

          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>

        <field name="networkTimeout" type="integer" mandatory="false"

          defaultValue="30000" group="Advanced">

          <description>The maximum period a connection or objects created from the connection will wait for the database to reply to any one request.</description>

        </field>

      </fields>

    </class>

    <class name="PostgreSQLStoreParameters">

      <extends>

        <class>JDBC2StoreParameters</class>

        <class>PostgreSQLResourceParameters</class>

      </extends>

      <fields/>

    </class>

    <class name="PostgreSQLNewStoreParameters">

      <extends>

        <class>JDBC2NewStoreParameters</class>

        <class>PostgreSQLResourceParameters</class>

      </extends>

      <fields/>

    </class>

    <class name="PostgreSQLServerExplorerParameters">

      <extends>

        <class>PostgreSQLResourceParameters</class>

        <class>JDBC2ServerExplorerParameters</class>

      </extends>

      <fields/>

    </class>

  </classes>

</definitions>  

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.postgresql.dal;

import java.sql.Connection;

import java.sql.DatabaseMetaData;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.fmap.dal.store.jdbc2.JDBCHelper;

import org.gvsig.fmap.dal.store.jdbc2.spi.JDBCSQLBuilderBase;

import org.gvsig.postgresql.dal.expressionbuilderformatter.PostgreSQLFormatter;

@SuppressWarnings("UseSpecificCatch")

public class PostgreSQLBuilder extends JDBCSQLBuilderBase {

    protected Formatter formatter = null;

    public static class Version {

        private final int major;

        private final int minor;

        public Version(int major, int minor) {

            this.major = major;

            this.minor = minor;

        }

        public int getMajor() {

            return major;

        }

        public int getMinor() {

            return minor;

        }

    }

    private Version databaseVersion = null;

    public Version getDatabaseVersion() {

        if( databaseVersion == null ) {

            Connection conn = null;

            try {

                conn = this.getHelper().getConnection();

                DatabaseMetaData metadata = conn.getMetaData();

                databaseVersion = new Version(

                    metadata.getDatabaseMajorVersion(),

                    metadata.getDatabaseMinorVersion()

                );

            } catch (Exception ex) {

                databaseVersion = new Version(0,0);

            } finally {

                this.getHelper().closeConnectionQuietly(conn);

            }

        }

        return databaseVersion;

    }

    public PostgreSQLBuilder(JDBCHelper helper) {

        super(helper);

        this.defaultSchema = "public";

        this.supportSchemas = true;

        this.allowAutomaticValues = true;

        this.geometrySupportType = this.helper.getGeometrySupportType();

        this.hasSpatialFunctions = this.helper.hasSpatialFunctions();

        this.STMT_DELETE_GEOMETRY_COLUMN_FROM_TABLE_schema_table = null;

        this.STMT_DELETE_GEOMETRY_COLUMN_FROM_TABLE_table = null;

        this.STMT_UPDATE_TABLE_STATISTICS_table = "ANALYZE {0}";

//        config.set(SQLConfig.ST_GeomFromEWKB, "ST_GeomFromEWKB({0}, {1})");

//        config.set(SQLConfig.ST_AsEWKB, "ST_AsEWKB(({0}))");        

//        config.set(SQLConfig.ST_ExtentAggregate, "ST_Extent({0})");        

//        config.set(SQLConfig.ST_UnionAggregate, "ST_Union({0})");

//        config.set(SQLConfig.isNull, "( ({0}) ISNULL )");

//        config.set(SQLConfig.notIsNull, "( ({0}) NOT NULL )");

    }

    public class PostgreSQLUpdateTableStatisticsBuilderBase extends UpdateTableStatisticsBuilderBase {

        @Override

        public List<String> toStrings() {

            List<String> sqls = new ArrayList<>();

            if( !StringUtils.isBlank(STMT_UPDATE_TABLE_STATISTICS_table) ) {

                // In postGIS, UpdateLayerStatistics function, don't allow to 

                // use the database name in the table name.

                String name = as_identifier(this.table.getName());

                if( table.has_schema()) {

                    name = as_identifier(this.table.getSchema()) + "." + name;

                }

                String sql = MessageFormat.format(

                        STMT_UPDATE_TABLE_STATISTICS_table,

                        name

                    );

                if( !StringUtils.isEmpty(sql) ) {

                    sqls.add(sql);

                }

            }

            return sqls;

        }        

    }

    protected class PostgreSQLCreateIndexBuilder extends CreateIndexBuilderBase {

        @Override

        public List<String> toStrings(Formatter formatter) {

            StringBuilder builder = new StringBuilder();

            builder.append("CREATE ");

//            if( this.isUnique ) {

//                builder.append("UNIQUE ");

//            }

            builder.append("INDEX ");

            if( this.ifNotExist ) {

                Version version = getDatabaseVersion();

                if( version.getMajor()>=9 && version.getMinor()>=5 ) {

                    builder.append("IF NOT EXISTS ");

                }

            }

            builder.append(as_identifier(this.indexName));

            builder.append(" ON ");

            builder.append(this.table.toString(formatter));

            if( this.isSpatial ) {

                builder.append(" USING GIST ");

            }

            builder.append(" ( ");

            boolean is_first_column = true;

            for( String column : this.columns) {

                if( is_first_column ) {

                    is_first_column = false;

                } else {

                    builder.append(", ");

                }

                builder.append(as_identifier(column));

            }

            builder.append(" )");

            List<String> sqls = new ArrayList<>();

            sqls.add(builder.toString());

            return sqls;

        }

    }

    protected class PostgreSQLCreateTableBuilder extends CreateTableBuilderBase {

        @Override

       public List<String> toStrings(Formatter formatter) {

           // 

           // https://www.postgresql.org/docs/9.1/static/sql-createtable.html

           //

            List<String> sqls = new ArrayList<>();

            StringBuilder builder = new StringBuilder();

            builder.append("CREATE TABLE ");

            builder.append(this.table.toString(formatter));

            builder.append(" (");

            boolean first = true;

            for (ColumnDescriptor column : columns) {

                if( column.isGeometry() ) {

                    continue;

                }

                if (first) {

                    first = false;

                } else {

                    builder.append(", ");

                }

                builder.append(as_identifier(column.getName()));

                builder.append(" ");

                if( column.isAutomatic() ) {

                    builder.append(" SERIAL");

                } else {

                    builder.append(sqltype(

                            column.getType(), 

                            column.getSize(),

                            column.getPrecision(), 

                            column.getScale(), 

                            column.getGeometryType(),

                            column.getGeometrySubtype()

                    ));

                    if (column.getDefaultValue() == null) {

                        if (column.allowNulls()) {

                            builder.append(" DEFAULT NULL");

                        }

                    } else {

                        builder.append(" DEFAULT '");

                        builder.append(column.getDefaultValue().toString());

                        builder.append("'");

                    }

                    if (column.allowNulls()) {

                        builder.append(" NULL");

                    } else {

                        builder.append(" NOT NULL");

                    }

                }

                if (column.isPrimaryKey()) {

                    builder.append(" PRIMARY KEY");

                }

            }

            builder.append(" )");

            sqls.add(builder.toString());

            String AddGeometryColumn = "SELECT AddGeometryColumn({0} , {1} , {2}, {3,number,#######} , {4} , {5}, {6})";

            for (ColumnDescriptor column : columns) {

                if( column.isGeometry() ) {

                    String sql = MessageFormat.format(

                        AddGeometryColumn,

                        as_string(this.table.has_schema()?this.table.getSchema():"public"),

                        as_string(this.table.getName()),

                        as_string(column.getName()),

                        column.getGeometrySRSId(),

                        as_string(sqlgeometrytype(column.getGeometryType(), column.getGeometrySubtype())),

                        as_string(sqlgeometrydimension(column.getGeometryType(), column.getGeometrySubtype())),

                        as_string(column.allowNulls())

                    );

                    sqls.add(sql);

                }

            }

            return sqls;

        }

    }

    public class PostgreSQLSelectBuilderBase extends SelectBuilderBase {

        @Override

        protected boolean isValid(StringBuilder message) {

            if( message == null ) {

                message = new StringBuilder();

            }

            if( this.has_offset() && !this.has_order_by() ) {

                // Algunos gestores de BBDD requieren que se especifique un

                // orden para poder usar OFFSET. Como eso parece buena idea para

                // asegurar que siempre tengamos los mismo resultados, lo exijimos

                // siempre.

                message.append("Can't use OFFSET without an ORDER BY.");

                return false;

            }

            return true;

        }        

        @Override

        public String toString(Formatter formatter) {

            //

            // https://www.postgresql.org/docs/9.1/static/sql-select.html

            //

            StringBuilder builder = new StringBuilder();

            if( !isValid(builder) ) {

                throw new IllegalStateException(builder.toString());

            }

            builder.append("SELECT ");

            if( this.distinct ) {

                builder.append("DISTINCT ");

            }

            boolean first = true;

            for (SelectColumnBuilder column : columns) {

                if (first) {

                    first = false;

                } else {

                    builder.append(", ");

                }

                builder.append(column.toString(formatter));

            }

            if ( this.has_from() ) {

                builder.append(" FROM ");

                builder.append(this.from.toString(formatter));

            }

            if ( this.has_where() ) {

                builder.append(" WHERE ");

                builder.append(this.where.toString(formatter));

            }

            if( this.has_group_by() ) {

                builder.append(" GROUP BY ");

                builder.append(this.groupColumn.get(0).toString(formatter));

                for (int i = 1; i < groupColumn.size(); i++) {

                    builder.append(", ");

                    builder.append(this.groupColumn.get(i).toString(formatter));

                }

            } 

            if( this.has_order_by() ) {

                builder.append(" ORDER BY ");

                first = true;

                for (OrderByBuilder item : this.order_by) {

                    if (first) {

                        first = false;

                    } else {

                        builder.append(", ");

                    }

                    builder.append(item.toString(formatter));

                }   

            }

            if ( this.has_limit() && this.has_offset() ) {

                builder.append(" OFFSET ");

                builder.append(this.offset);

                builder.append(" FETCH NEXT ");

                builder.append(this.limit);

                builder.append(" ROWS ONLY");

            } else if ( this.has_limit()) {

                builder.append(" LIMIT ");

                builder.append(this.limit);

            } else if ( this.has_offset() ) {

                builder.append(" LIMIT ALL OFFSET ");

                builder.append(this.offset);    

            }

            return builder.toString();

        }

    }

    @Override

    protected Formatter formatter() {

        if( this.formatter==null ) {

            this.formatter = new PostgreSQLFormatter(this);

        }

        return this.formatter;

    }

    @Override

    public PostgreSQLHelper getHelper() {

        return (PostgreSQLHelper) helper;

    }

    @Override

    protected CreateTableBuilder createCreateTableBuilder() {

        return new PostgreSQLCreateTableBuilder();

    }

    @Override

    protected CreateIndexBuilder createCreateIndexBuilder() {

        return new PostgreSQLCreateIndexBuilder();

    }

    @Override

    protected SelectBuilder createSelectBuilder() {

        return new PostgreSQLSelectBuilderBase();

    }

    @Override

    protected UpdateTableStatisticsBuilder createUpdateTableStatisticsBuilder() {

        return new PostgreSQLUpdateTableStatisticsBuilderBase();

    }       

}

package org.gvsig.postgresql.dal.expressionbuilderformatter;

import java.text.MessageFormat;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

import static org.gvsig.expressionevaluator.ExpressionBuilder.OPERATOR_ILIKE;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.fmap.dal.SQLBuilder;

/**

 *

 * @author jjdelcerro

 */

class ILike implements Formatter<Value> {

    private final Formatter<Value> formatter;

    private final SQLBuilder builder;

    public ILike(SQLBuilder builder, Formatter<Value> formatter) {

        this.builder = builder;

        this.formatter = formatter;

    }

    @Override

    public boolean canApply(Value value) {

        if (value instanceof Function) {

            return StringUtils.equalsIgnoreCase(OPERATOR_ILIKE, ((Function) value).name());

        }

        return false;

    }

    @Override

    public String format(Value function) {

        List<Value> parameters = ((Function) function).parameters();

        String p1 = parameters.get(0).toString(formatter);

        String p2 = parameters.get(1).toString(formatter);

        String r = MessageFormat.format("({0}) ~~* ({1})", p1, p2);

        return r;

    }

}

package org.gvsig.postgresql.dal.expressionbuilderformatter;

import java.util.List;

import java.util.Objects;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import static org.gvsig.expressionevaluator.ExpressionBuilder.FUNCTION_DECODE;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.fmap.dal.SQLBuilder;

/**

 *

 * @author jjdelcerro

 */

public class Decode implements Formatter<Value> {

    private final SQLBuilder sqlbuilder;

    private final Formatter<Value> formatter;

    public Decode(SQLBuilder sqlbuilder, Formatter<Value> formatter) {

        this.sqlbuilder = sqlbuilder;

        this.formatter = formatter;

    }

    @Override

    public boolean canApply(ExpressionBuilder.Value value) {

        if (value instanceof ExpressionBuilder.Function) {

            if( StringUtils.equalsIgnoreCase(FUNCTION_DECODE, ((Function) value).name()) ) {

                List<Value> parameters = ((Function) value).parameters();

                if( parameters.size()==2) {

                    Value p1 = parameters.get(0);

                    Value p2 = parameters.get(1);

                    if( p1 instanceof ExpressionBuilder.Constant && 

                        p2 instanceof ExpressionBuilder.Constant &&

                        ((ExpressionBuilder.Constant)p1).value() instanceof String &&

                        ((ExpressionBuilder.Constant)p2).value() instanceof String 

                        ) {

                        String p2value = ((ExpressionBuilder.Constant)p2).value().toString();

                        if( StringUtils.equalsIgnoreCase(p2value, "hex") ) {

                            return true;

                        }

                    }

                }

            }

        }

        return false;

    }

    @Override

    public String format(Value function) {

        ExpressionBuilder builder = this.sqlbuilder.expression();

        List<Value> parameters = ((Function) function).parameters();

        Value p1 = parameters.get(0);

        String p1value = Objects.toString(((ExpressionBuilder.Constant)p1).value(), "");

        String r = builder.string("\\x"+p1value)+"::bytea";

        return r;

    }

}

package org.gvsig.postgresql.dal.expressionbuilderformatter;

import java.text.MessageFormat;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import static org.gvsig.expressionevaluator.GeometryExpressionBuilder.FUNCTION_ST_EXTENTAGGREGATE;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.fmap.dal.SQLBuilder;

/**

 *

 * @author jjdelcerro

 */

public class ST_ExtentAggregate implements Formatter<Value> {

    private final SQLBuilder sqlbuilder;

    private final Formatter<Value> formatter;

    public ST_ExtentAggregate(SQLBuilder sqlbuilder, Formatter<Value> formatter) {

        this.sqlbuilder = sqlbuilder;

        this.formatter = formatter;

    }

    @Override

    public boolean canApply(ExpressionBuilder.Value value) {

        if (value instanceof ExpressionBuilder.Function) {

            return StringUtils.equalsIgnoreCase(FUNCTION_ST_EXTENTAGGREGATE, ((Function) value).name());

        }

        return false;

    }

    @Override

    public String format(Value function) {

        List<Value> parameters = ((Function) function).parameters();

        String p1 = parameters.get(0).toString(formatter);

        String r = MessageFormat.format("ST_Extent({0})", p1);

        return r;

    }

}

package org.gvsig.postgresql.dal.expressionbuilderformatter;

import java.text.MessageFormat;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import org.gvsig.fmap.dal.SQLBuilder;

import org.gvsig.fmap.dal.feature.FeatureType;

import static org.gvsig.fmap.dal.store.jdbc2.spi.JDBCSQLBuilderBase.PROP_FEATURE_TYPE;

/**

 *

 * @author jjdelcerro

 */

public class ST_GeomFromWKB implements Formatter<Value> {

    private final SQLBuilder sqlbuilder;

    private final Formatter<Value> formatter;

    public ST_GeomFromWKB(SQLBuilder sqlbuilder, Formatter<Value> formatter) {

        this.sqlbuilder = sqlbuilder;

        this.formatter = formatter;

    }

    @Override

    public boolean canApply(ExpressionBuilder.Value value) {

        if (value instanceof ExpressionBuilder.Function) {

            return StringUtils.equalsIgnoreCase(GeometryExpressionBuilder.FUNCTION_ST_GEOMFROMWKB, ((Function) value).name());

        }

        return false;

    }

    @Override

    public String format(Value function) {

        String r;

        String wkb;

        String srid;

        List<Value> parameters = ((Function) function).parameters();

        switch(parameters.size()) {

            case 1:

                wkb = parameters.get(0).toString(formatter);

                r = MessageFormat.format("ST_GeomFromWKB({0})", wkb);

                break;

            case 2:

                wkb = parameters.get(0).toString(formatter);

                srid = parameters.get(1).toString(formatter);

                if( StringUtils.equals("0", srid) ) {

                    r = MessageFormat.format("ST_GeomFromWKB({0})", wkb);

                } else {

                    FeatureType ftype = (FeatureType) function.getProperty(PROP_FEATURE_TYPE);

                    if( ftype == null || ftype.getDefaultSRS()!=null ) {

                        r = MessageFormat.format("ST_GeomFromWKB({0},{1})", wkb, srid);

                    } else {

                        r = MessageFormat.format("ST_GeomFromWKB({0})", wkb);

                    }

                }

                break;

            default:

                throw new IllegalArgumentException("Wrong number of arguments ("+parameters.size()+") in function ST_GeomFromWKB; requiered 1 or 2 arguments.");

        }

        return r;

    }

}

package org.gvsig.postgresql.dal.expressionbuilderformatter;

import java.text.MessageFormat;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code.Constant;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

import static org.gvsig.expressionevaluator.ExpressionBuilder.OPERATOR_IS;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.fmap.dal.SQLBuilder;

/**

 *

 * @author jjdelcerro

 */

class IsNull implements Formatter<Value> {

    private final Formatter<Value> formatter;

    private final SQLBuilder builder;

    public IsNull(SQLBuilder builder, Formatter<Value> formatter) {

        this.builder = builder;

        this.formatter = formatter;

    }

    @Override

    public boolean canApply(Value value) {

        if (value instanceof Function) {

            if( StringUtils.equalsIgnoreCase(OPERATOR_IS, ((Function) value).name()) ) {

                List<Value> parameters = ((Function) value).parameters();

                Value p2 = parameters.get(1);

                if( p2 instanceof Constant && ((Constant)p2).value()==null ) {

                    return true;

                }

            }

        }

        return false;

    }

    @Override

    public String format(Value function) {

        List<Value> parameters = ((Function) function).parameters();

        String p1 = parameters.get(0).toString(formatter);

        String r = MessageFormat.format("( ({0}) ISNULL )", p1);

        return r;

    }

}

package org.gvsig.postgresql.dal.expressionbuilderformatter;

import java.text.MessageFormat;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import org.gvsig.fmap.dal.SQLBuilder;

import org.gvsig.fmap.dal.feature.FeatureType;

import static org.gvsig.fmap.dal.store.jdbc2.spi.JDBCSQLBuilderBase.PROP_FEATURE_TYPE;

/**

 *

 * @author jjdelcerro

 */

public class ST_GeomFromText implements Formatter<Value> {

    private final SQLBuilder sqlbuilder;

    private final Formatter<Value> formatter;

    public ST_GeomFromText(SQLBuilder sqlbuilder, Formatter<Value> formatter) {

        this.sqlbuilder = sqlbuilder;

        this.formatter = formatter;

    }

    @Override

    public boolean canApply(ExpressionBuilder.Value value) {

        if (value instanceof ExpressionBuilder.Function) {

            return StringUtils.equalsIgnoreCase(GeometryExpressionBuilder.FUNCTION_ST_GEOMFROMTEXT, ((Function) value).name());

        }

        return false;

    }

    @Override

    public String format(Value function) {

        String r;

        String wkt;

        String srid;

        List<Value> parameters = ((Function) function).parameters();

        switch(parameters.size()) {

            case 1:

                wkt = parameters.get(0).toString(formatter);

                r = MessageFormat.format("ST_GeomFromText({0})", wkt);

                break;

            case 2:

                wkt = parameters.get(0).toString(formatter);

                srid = parameters.get(1).toString(formatter);

                if( StringUtils.equals("0", srid) ) {

                    r = MessageFormat.format("ST_GeomFromText({0})", wkt);

                } else {

                    FeatureType ftype = (FeatureType) function.getProperty(PROP_FEATURE_TYPE);

                    if( ftype == null || ftype.getDefaultSRS()!=null ) {

                        r = MessageFormat.format("ST_GeomFromText({0},{1})", wkt, srid);

                    } else {

                        r = MessageFormat.format("ST_GeomFromText({0})", wkt);

                    }

                }

                break;

            default:

                throw new IllegalArgumentException("Wrong number of arguments ("+parameters.size()+") in function ST_GeomFromText; requiered 1 or 2 arguments.");

        }

        return r;

    }

}

package org.gvsig.postgresql.dal.expressionbuilderformatter;

import java.text.MessageFormat;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code.Constant;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

import static org.gvsig.expressionevaluator.ExpressionBuilder.OPERATOR_IS;

import static org.gvsig.expressionevaluator.ExpressionBuilder.OPERATOR_NOT;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.fmap.dal.SQLBuilder;

/**

 *

 * @author jjdelcerro

 */

class IsNotNull implements Formatter<Value> {

    private final Formatter<Value> formatter;

    private final SQLBuilder builder;

    public IsNotNull(SQLBuilder builder, Formatter<Value> formatter) {

        this.builder = builder;

        this.formatter = formatter;

    }

    @Override

    public boolean canApply(Value value_not) {

        if (value_not instanceof Function) {

            // NOT( IS( p1, NULL) )

            if( StringUtils.equalsIgnoreCase(OPERATOR_NOT, ((Function) value_not).name()) ) {

                List<Value> parameters = ((Function) value_not).parameters();

                Value value_is = parameters.get(0);

                if( value_is instanceof Function && StringUtils.equalsIgnoreCase(OPERATOR_IS, ((Function)value_is).name()) ) {

                    List<Value> parameters_is = ((Function) value_is).parameters();

                    Value is_p2 = parameters_is.get(1);

                    if( is_p2 instanceof Constant && ((Constant)is_p2).value()==null ) {

                        return true;

                    }

                }

            }

        }

        return false;

    }

    @Override

    public String format(Value value_not) {

        // NOT( IS( p1, NULL) )

        List<Value> parameters = ((Function) value_not).parameters();

        Value value_is = parameters.get(0);

        List<Value> parameters_is = ((Function)value_is).parameters();

        Value is_p1 = parameters_is.get(0);

        String r = MessageFormat.format(

                "( ({0}) IS NOT NULL )", 

                is_p1.toString(formatter)

        );

        return r;

    }

}

package org.gvsig.postgresql.dal.expressionbuilderformatter;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.SQLBuilder;

import org.gvsig.fmap.dal.store.jdbc2.spi.expressionbuilder.formatters.Exists;

/**

 *

 * @author jjdelcerro

 */

public class PostgreSQLFormatter implements Formatter<Value> {

    private final SQLBuilder builder;

    private final Formatter<ExpressionBuilder.Value>[] formatters;

    @SuppressWarnings("LeakingThisInConstructor")

    public PostgreSQLFormatter(SQLBuilder builder) {

        this.builder = builder;

        this.formatters = new Formatter[]{

            new Decode(this.builder, this),

            new Constant(this.builder, this),

            new ILike(this.builder, this),

            new IfNull(this.builder, this),

            new IsNull(this.builder, this),

            new IsNotNull(this.builder, this),

            new ST_ExtentAggregate(this.builder, this),

            new ST_GeomFromWKB(this.builder, this),

            new ST_GeomFromText(this.builder, this),

            new Getattr(this.builder, this),

//            new Iff(this),

            new Exists(this),

            DALLocator.getDataManager().createDALExpressionBuilder().formatter(this),

        };

    }

    @Override

    public boolean canApply(Value value) {

        for (Formatter<Value> formatter : formatters) {

            if (formatter.canApply(value)) {

                return true;

            }

        }

        return false;

    }

    @Override

    public String format(Value value) {

        for (Formatter<Value> formatter : formatters) {

            if (formatter.canApply(value)) {

                return formatter.format(value);

            }

        }

        return value.toString(this);

    }

}

package org.gvsig.postgresql.dal.expressionbuilderformatter;

import java.text.MessageFormat;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import org.gvsig.fmap.dal.SQLBuilder;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryUtils;

/**

 *

 * @author jjdelcerro

 */

public class Constant implements Formatter<Value> {

    private static final String FORMAT_ST_GEOMFROMWKB = "ST_GeomFromWKB(({0}), ({1}))";

    private static final String FORMAT_ST_GEOMFROMEWKB = "ST_GeomFromEWKB(({0}), ({1}))";

    private static final String FORMAT_ST_GEOMFROMTEXT = "ST_GeomFromText(({0}), ({1}))";

    private final SQLBuilder sqlbuilder;

    private final Formatter<Value> formatter;

    public Constant(SQLBuilder sqlbuilder, Formatter<Value> formatter) {

        this.sqlbuilder = sqlbuilder;

        this.formatter = formatter;

    }

    @Override

    public boolean canApply(ExpressionBuilder.Value value) {

        if (value instanceof ExpressionBuilder.Constant) {

            Object x = ((ExpressionBuilder.Constant)value).value();

            if( x instanceof byte[] ) {

                return true;

            }

            if( x instanceof Geometry ) {

                return true;

            }

        }

        return false;

    }

    @Override

    public String format(Value constant) {

        Object x = ((ExpressionBuilder.Constant)constant).value();

        GeometryExpressionBuilder builder = this.sqlbuilder.expression();

        if( x instanceof byte[] ) {

            return builder.string("\\x"+builder.bytearray_hex((byte[]) x))+"::bytea";

        }

        if( x instanceof Geometry ) {

            Geometry geometry = (Geometry) x;

            switch (builder.geometry_support_type()) {

                case EWKB:

                    return MessageFormat.format(

                            FORMAT_ST_GEOMFROMEWKB,

                            builder.string("\\x"+builder.bytearray_hex(GeometryUtils.toEWKB(geometry)))+"::bytea",

                            String.valueOf(builder.srs_id(geometry.getProjection()))

                    );

                case WKB:

                    return MessageFormat.format(

                            FORMAT_ST_GEOMFROMWKB,

                            builder.string("\\x"+builder.bytearray_hex(GeometryUtils.toWKB(geometry)))+"::bytea",

                            String.valueOf(builder.srs_id(geometry.getProjection()))

                    );

                case WKT:

                default:

                    return MessageFormat.format(

                            FORMAT_ST_GEOMFROMTEXT,

                            builder.string(GeometryUtils.toWKT(geometry)),

                            String.valueOf(builder.srs_id(geometry.getProjection()))

                    );

            }

        }

        return null;

    }

}

package org.gvsig.postgresql.dal.expressionbuilderformatter;

import java.text.MessageFormat;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import static org.gvsig.expressionevaluator.ExpressionBuilder.FUNCTION_IFNULL;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.fmap.dal.SQLBuilder;

/**

 *

 * @author jjdelcerro

 */

class IfNull implements Formatter<Value> {

    private final Formatter<Value> formatter;

    private final SQLBuilder builder;

    public IfNull(SQLBuilder builder, Formatter<Value> formatter) {

        this.builder = builder;

        this.formatter = formatter;

    }

    @Override

    public boolean canApply(Value value) {

        if (value instanceof Function) {

            if (value instanceof ExpressionBuilder.Function) {

                return StringUtils.equalsIgnoreCase(FUNCTION_IFNULL, ((Function) value).name());

            }

        }

        return false;

    }

    @Override

    public String format(Value function) {

            List<Value> parameters = ((Function) function).parameters();

            String p1 = parameters.get(0).toString(formatter);

            String p2 = parameters.get(1).toString(formatter);

            String p3 = parameters.get(2).toString(formatter);

            String r = MessageFormat.format(

                    "CASE WHEN ({0}) IS NULL THEN ({1}) ELSE ({2}) END",

                    p1,

                    p3,

                    p2

            );

            return r;

    }

}

package org.gvsig.postgresql.dal.expressionbuilderformatter;

import org.apache.commons.lang3.StringUtils;

import static org.gvsig.expressionevaluator.ExpressionBuilder.FUNCTION_GETATTR;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.ExpressionBuilder.Variable;

import org.gvsig.expressionevaluator.ExpressionBuilder.Constant;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.fmap.dal.SQLBuilder;

/**

 *

 * @author jjdelcerro

 */

public class Getattr implements Formatter<Value> {

    private final SQLBuilder sqlbuilder;

    private final Formatter<Value> formatter;

    public Getattr(SQLBuilder sqlbuilder, Formatter<Value> formatter) {

        this.sqlbuilder = sqlbuilder;

        this.formatter = formatter;

    }

    @Override

    public boolean canApply(Value value) {

        if (value instanceof Function) {

            if( StringUtils.equalsIgnoreCase(FUNCTION_GETATTR, ((Function) value).name()) ) {

              Value obj = ((Function) value).parameters().get(0);

              Value attrname = ((Function) value).parameters().get(1);

              return obj instanceof Variable && attrname instanceof Constant;

            }

        }

        return false;

    }

    @Override

    public String format(Value function0) {

        Function function = (Function) function0;

        Variable obj = (Variable) function.parameters().get(0);

        Constant attrname = (Constant) function.parameters().get(1);

        return this.sqlbuilder.as_identifier(obj.name())+"."+this.sqlbuilder.as_identifier((String) attrname.value());

    }

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.postgresql.dal;

import org.gvsig.fmap.dal.store.jdbc2.spi.FakeConnectionParameters;

/**

 *

 * @author fdiaz

 */

public class FakePostgreSQLConnectionParameters extends FakeConnectionParameters implements PostgreSQLConnectionParameters {

    @Override

    public boolean getUseSSL() {

        return false;

    }

    @Override

    public int getMaxIdle() {

        return 8;

    }

    @Override

    public int getNetworkTimeout() {

        return 30000;

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.postgresql.dal;

import org.gvsig.fmap.dal.exception.ValidateDataParametersException;

import org.gvsig.fmap.dal.store.jdbc.JDBCNewStoreParameters;

public class PostgreSQLNewStoreParameters 

    extends 

        JDBCNewStoreParameters 

    implements 

        PostgreSQLConnectionParameters 

    {

    private final PostgreSQLConnectionParametersHelper helper;

    public PostgreSQLNewStoreParameters() {

        super(

            PostgreSQLLibrary.NAME + "NewStoreParameters", 

            PostgreSQLLibrary.NAME

        );

        this.helper = new PostgreSQLConnectionParametersHelper(this);

    }

    @Override

    public String getUrl() {

        return this.helper.getUrl();

    }

    @Override

    public void validate() throws ValidateDataParametersException {

        this.helper.validate();

    }

    @Override

    public boolean getUseSSL() {

        return this.helper.getUseSSL();

    }

    @Override

    public int getMaxIdle() {

        return this.helper.getMaxIdle();

    }

    public void setUseSSL(boolean v) {

        this.helper.setUseSSL(v);

    }

    @Override

    public int getNetworkTimeout() {

        return this.helper.getNetworkTimeout();

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation; either version 2

* of the License, or (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU General Public License for more details.

*

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

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

* MA  02110-1301, USA.

*

 */

/**

 *

 */

package org.gvsig.postgresql.dal;

import org.gvsig.fmap.dal.exception.ValidateDataParametersException;

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;

public class PostgreSQLServerExplorerParameters extends

        JDBCServerExplorerParameters 

    implements

        PostgreSQLConnectionParameters

    {

    private final PostgreSQLConnectionParametersHelper helper;

    public PostgreSQLServerExplorerParameters() {

        super(

                PostgreSQLLibrary.NAME + "ServerExplorerParameters",

                PostgreSQLLibrary.NAME

        );

        this.helper = new PostgreSQLConnectionParametersHelper(this);

    }

    @Override

    public String getUrl() {

        return this.helper.getUrl();

    }

    @Override

    public void validate() throws ValidateDataParametersException {

        // Esto seria para convertir los parametros de gvSIG 2.3 a 2.4.

//        if( !StringUtils.equalsIgnoreCase(PostgreSQLLibrary.NAME, (CharSequence) getDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME)) ) {

//            setDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME, PostgreSQLLibrary.NAME);

//        }

        this.helper.validate();

        super.validate();        

    }

    @Override

    public boolean getUseSSL() {

        return this.helper.getUseSSL();

    }

    @Override

    public int getMaxIdle() {

        return this.helper.getMaxIdle();

    }

    public void setUseSSL(boolean v) {

        this.helper.setUseSSL(v);

    }

    @Override

    public int getNetworkTimeout() {

        return this.helper.getNetworkTimeout();

    }

}

package org.gvsig.postgresql.dal;

import java.io.IOException;

import java.sql.Connection;

import java.sql.SQLException;

import org.apache.commons.dbcp2.BasicDataSource;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.GeometryExpressionBuilderHelper.GeometrySupportType;

import org.gvsig.fmap.dal.resource.exception.AccessResourceException;

import org.gvsig.fmap.dal.store.jdbc.JDBCConnectionParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCNewStoreParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCStoreParameters;

import org.gvsig.fmap.dal.store.jdbc.exception.JDBCDriverClassNotFoundException;

import org.gvsig.fmap.dal.store.jdbc2.JDBCUtils;

import org.gvsig.fmap.dal.store.jdbc2.OperationsFactory;

import org.gvsig.fmap.dal.store.jdbc2.spi.ConnectionProvider;

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.SRSSolverBase;

import org.gvsig.fmap.dal.store.jdbc2.spi.SRSSolverDumb;

import org.gvsig.postgresql.dal.operations.PostgreSQLOperationsFactory;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.exception.BaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class PostgreSQLHelper extends JDBCHelperBase {

    /* friend */ static final Logger LOGGER = LoggerFactory.getLogger(PostgreSQLHelper.class);

    public static final String POSTGRESQL_JDBC_DRIVER = "org.postgresql.Driver";

    public static String getConnectionURL(PostgreSQLConnectionParameters params) {

        return getConnectionURL(

            params.getHost(),

            params.getPort(),

            params.getDBName()

        );

    }

    public static String getConnectionURL(String host, Integer port, String db) {

        if( StringUtils.isEmpty(host) ) {

            throw new IllegalArgumentException("Parameter 'host' can't be null.");

        }

        String connectionURL = "jdbc:postgresql://" + host;

        if (port != null) {

            connectionURL = connectionURL + ":" + port;

        }

        connectionURL = connectionURL + "/" + db;

        LOGGER.debug("connectionURL: {}", connectionURL);

        return connectionURL;

    }

    private static class PostgreSQLConnectionProvider implements Disposable, ConnectionProvider {

        private static boolean needRegisterDriver = true;

        private BasicDataSource dataSource = null;

        private PostgreSQLConnectionParameters connectionParameters;

        public PostgreSQLConnectionProvider(PostgreSQLConnectionParameters connectionParameters) {

            this.connectionParameters = connectionParameters;

        }

        public Connection getConnection() throws SQLException {

            if (this.dataSource == null) {

                this.dataSource = this.createDataSource();               

            }

            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;

            }

            try {

                conn.setNetworkTimeout(null, this.connectionParameters.getNetworkTimeout());

            } catch(Throwable ex) {

                LOGGER.warn("Error setting the network timeout.",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 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("  MaxTotal: ").append(this.dataSource.getMaxTotal()).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()) {

                this.registerDriver();

            }

            PostgreSQLConnectionParameters params = connectionParameters;

            BasicDataSource ds = new BasicDataSource();

            ds.setMaxIdle(params.getMaxIdle());

            ds.setDriverClassName(params.getJDBCDriverClassName());

            if( params.getUseSSL() ) {

                String s = BooleanUtils.toStringTrueFalse(params.getUseSSL());

                ds.addConnectionProperty("ssl", s );

            }

            if( !StringUtils.isEmpty(params.getUser()) ) {

                ds.setUsername(params.getUser());

            }

            if( !StringUtils.isEmpty(params.getPassword()) ) {

                ds.setPassword(params.getPassword());

            }

            ds.setUrl(params.getUrl());