Application: gvSIG desktop

                false,

                false,

                false,

import org.gvsig.fmap.dal.ExpressionBuilder.Config;

        double tolerance = -1 ; //query.getScale();

                if( tolerance<=0 || !sqlbuilder.getConfig().has_functionality(Config.ST_Simplify)) {

                    sqlbuilder.select().column().name(attr.getName()).as_geometry();

                } else {

                    sqlbuilder.select().column().value(

                        sqlbuilder.ST_Simplify( 

                            sqlbuilder.column(attr.getName()),

                            sqlbuilder.constant(tolerance)

                        )

                    ).as_geometry();

                }

    protected String dbName;

    protected String schemaName;

    protected String tableName;

    protected FeatureType featureType;

    protected Iterator<FeatureReferenceProviderServices> deleteds;

    protected Iterator<FeatureStoreProvider.FeatureTypeChanged> featureTypesChanged;

    protected Iterator<FeatureProvider> updateds;

    protected Iterator<FeatureProvider> inserteds;

    protected boolean typeChanged = false;

                        attrTarget.isIndexed(),

                        attrTarget.isIndexed(),

        // En algunos gestores de BBDD, los nombres obtenidos de las pks de los 

        // metadados no coinciden con los nombres de los campos ya que unos estan

        // en mayusculas y otros en minusculas, asi que en lugar de usar un "contains"

        // nos los recorremos y comparamos con IgnoreCase.

        for (String pk : pks) {

            if( StringUtils.equalsIgnoreCase(pk, attr.getName()) ) {

                return true;

            }

        }

        return false;        

                        attr.isIndexed(),

                        attr.isIndexed(),

package org.gvsig.fmap.dal.store.jdbc2.spi;

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

public class JDBCSRSsDumb extends JDBCSRSsBase implements JDBCSRSs {

    public JDBCSRSsDumb(JDBCHelper helper) {

        super(helper);

    }

    @Override

    protected String searchDatabaseCode(String applicationAbbrev) {

        try {

            String[] s = applicationAbbrev.split(applicationAbbrev);

            return s[1].trim();

        } catch (Throwable ex) {

            throw new RuntimeException("Problems searching database code from '"+applicationAbbrev+"'.",ex);

        }

    }

    @Override

    protected String searchApplicationAbbrev(String databaseCode) {

        try {

            return "EPSG:" + databaseCode.trim();

        } catch (Throwable ex) {

            throw new RuntimeException("Problems searching application abbrev from '"+databaseCode+"'.",ex);

        }

    }    

}

package org.gvsig.fmap.dal.store.jdbc2.spi;

import java.sql.ResultSet;

import java.sql.Statement;

import java.util.HashMap;

import java.util.Map;

import org.apache.commons.lang3.StringUtils;

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

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

public class JDBCSRSsBase implements JDBCSRSs {

    protected Map<String,String> database2applicationAbbrev;

    protected Map<String,String> applicationAbbrev2database;

    protected JDBCHelper helper;

    public JDBCSRSsBase(JDBCHelper helper) {

        this.helper = helper;

        this.applicationAbbrev2database = new HashMap<>();

        this.database2applicationAbbrev = new HashMap<>();

    }

    public void add(String databaseCode, String applicationAbbrev) {

        this.applicationAbbrev2database.put(applicationAbbrev, databaseCode);

        this.database2applicationAbbrev.put(databaseCode, applicationAbbrev);

    }

    public String getDatabaseCode(String applicationAbbrev) {

        if( this.hasApplicationAbbrev(applicationAbbrev) ) {

            return this.applicationAbbrev2database.get(applicationAbbrev);

        }

        String databaseCode = this.searchDatabaseCode(applicationAbbrev);

        if( StringUtils.isEmpty(databaseCode) ) {

            return null;

        }

        this.add(databaseCode, applicationAbbrev);

        return databaseCode;

    }

    public String getApplicationAbbrev(String databaseCode) {

        if( this.hasDatabaseCode(databaseCode) ) {

            return this.database2applicationAbbrev.get(databaseCode);

        }

        String applicationAbbrev = this.searchApplicationAbbrev(databaseCode);

        if( StringUtils.isEmpty(applicationAbbrev) ) {

            return null;

        }

        this.add(databaseCode, applicationAbbrev);

        return applicationAbbrev;

    }

    public boolean hasDatabaseCode(String databaseCode) {

        return this.database2applicationAbbrev.containsKey(databaseCode);

    }

    public boolean hasApplicationAbbrev(String applicationAbbrev) {

        return this.applicationAbbrev2database.containsKey(applicationAbbrev);

    }

    protected String searchDatabaseCode(String applicationAbbrev) {

        // Initialize sql only for debugging purposes

        String sql = "select srid, auth_name, auth_srid from spatial_ref_sys where auth_name/auth_srid is '"+applicationAbbrev+"'.";

        try {

            String[] s = applicationAbbrev.split(applicationAbbrev);

            sql = "select srid, auth_name, auth_srid from spatial_ref_sys where auth_name = '" + s[0] +"' and auth_srid = '"+s[1]+"' ";

            Statement st = this.helper.getConnection().createStatement();

            ResultSet rs = JDBCUtils.executeQuery(st, sql);

            if ( rs.next() ) {

                int srid = rs.getInt("srid");

                return String.valueOf(srid);

            }            

            return null;

        } catch (Throwable ex) {

            throw new RuntimeException("Problems with SQL '"+sql+"'.",ex);

        }

    }

    protected String searchApplicationAbbrev(String databaseCode) {

        String sql = "select srid, auth_name, auth_srid from spatial_ref_sys where srid = " + databaseCode;

        try {

            Statement st = this.helper.getConnection().createStatement();

            ResultSet rs = JDBCUtils.executeQuery(st, sql);

            if ( rs.next() ) {

                int auth_code = rs.getInt("auth_srid");

                String auth_name = rs.getString("auth_name");

                return auth_name + ":" + auth_code;

            }            

            return null;

        } catch (Throwable ex) {

            throw new RuntimeException("Problems with SQL '"+sql+"'.",ex);

        }

    }

}

    protected JDBCSRSs srss;

        // If a particular treatment is required to convert SRS to the 

        // BBDD format, overwrite JDBCSRSsBase and use it instead of JDBCSRSsDumb.

        this.srss = new JDBCSRSsDumb(this);

        String databaseCode = this.srss.getDatabaseCode(crs.getAbrev());

        return Integer.parseInt(databaseCode);

        return getProjectionFromDatabaseCode(String.valueOf(srsid));

    }

    @Override

    public String getDatabaseCodeFromProyection(IProjection proj) {

        String[] s = proj.getAbrev().split(":");

        return this.srss.getDatabaseCode(proj.getAbrev());

    }

    @Override

    public IProjection getProjectionFromDatabaseCode(String databaseCode) {

        String abbrev = this.srss.getApplicationAbbrev(databaseCode);

        if( StringUtils.isEmpty(abbrev) ) {

        IProjection proj = CRSFactory.getCRS(abbrev);

package org.gvsig.fmap.dal.store.jdbc2.spi;

public interface JDBCSRSs {

    void add(String databaseCode, String applicationAbbrev);

    String getApplicationAbbrev(String databaseCode);

    String getDatabaseCode(String applicationAbbrev);

    boolean hasApplicationAbbrev(String applicationAbbrev);

    boolean hasDatabaseCode(String databaseCode);

}

    public String getDatabaseCodeFromProyection(IProjection proj);

    public IProjection getProjectionFromDatabaseCode(String databaseCode);

    /**

     * @param crs

     * @return 

     * @deprecated use getDatabaseCodeFromProyection

     */

    /**

     * @param srsid

     * @return 

     * @deprecated use getProjectionFromDatabaseCode

     */

    private static final Logger logger = LoggerFactory.getLogger(DefaultJDBCConnectionPanel.class);

    private static final long serialVersionUID = -6119489353793596382L;

    private ItemListener onChangeConnectorItemListener;

                if(e.getStateChange() != ItemEvent.SELECTED) {

                    return;

                }                // Lo hago asi para evitar cuelgues durante la depuracion

        this.onChangeConnectorItemListener = new ItemListener() {

                if(e.getStateChange() != ItemEvent.SELECTED) {

                    return;

                }

        };

        this.cboConnectors.addItemListener(onChangeConnectorItemListener);

            this.cboConnectors.removeItemListener(this.onChangeConnectorItemListener);

            this.cboConnectors.addItemListener(onChangeConnectorItemListener);

        if( connector==null ) {

            return null;

        }

                if ( x.getParams()!=null && x.getParams().getExplorerName().equalsIgnoreCase(explorerParameters.getExplorerName()) ) {

        this.cboConnectors.addItem(new ServerExplorerParametersComboItem("",null));

        public final static String support_schemas = "support_schemas";

        public final static String ST_Simplify = "ST_Simplify";        

    public Function ST_Simplify(Value geom, Value tolerance);

        public final static String CREATE_INDEX_name_ON_table_column = "CREATE_INDEX_name_ON_table_column";

        public final static String CREATE_INDEX_name_ON_table_USING_GIST_column = "CREATE_INDEX_name_ON_table_USING_GIST_column";

        public boolean isIndexed();

        public AlterTableBuilder add_column(String columnName, int type, int type_p, int type_s, boolean isPk, boolean isIndexed, boolean allowNulls, boolean isAutomatic, Object defaultValue);

        public AlterTableBuilder alter_column(String columnName, int type, int type_p, int type_s, boolean isPk, boolean isIndexed, boolean allowNulls, boolean isAutomatic, Object defaultValue);

        public CreateTableBuilder add_column(String columnName, int type, int type_p, int type_s, boolean isPk, boolean isIndexed, boolean allowNulls, boolean isAutomatic, Object defaultValue);

        public CreateTableBuilder add_geometry_column(String columnName, int geom_type, int geom_subtype, IProjection proj, boolean isIndexed, boolean allowNulls);

    public boolean supportSchemas();

            this.set(Config.has_spatial_functions, false);

            this.set(Config.support_schemas, true);

            this.set(Config.constant_true, "(1=1)");

            this.set(Config.constant_false, "(1=2)");

            this.set(Config.quote_for_identifiers, "\"");

            this.set(Config.quote_for_strings, "'");

            this.set(Config.geometry_type_support, GeometrySupportType.WKT);

            this.set(Config.group, "( {0} )");

            this.set(Config.Find_SRID, "Find_SRID(({0}), ({1}), ({2}))");

            this.set(Config.ST_SRID, "ST_SRID({0})");

            this.set(Config.ST_AsText, "ST_AsText({0})");

            this.set(Config.ST_AsBinary, "ST_AsBinary({0})");

            this.set(Config.ST_AsEWKB, "ST_AsEWKB({0})");

            this.set(Config.ST_Contains, "ST_Contains(({0}), ({1}))");

            this.set(Config.ST_Crosses, "ST_Crosses(({0}), ({1}))");

            this.set(Config.ST_Disjoint, "ST_Disjoint(({0}), ({1}))");

            this.set(Config.ST_Equals, "ST_Equals(({0}), ({1}))");

            this.set(Config.ST_IsClosed, "ST_IsClosed({0})");

            this.set(Config.ST_Overlaps, "ST_Overlaps(({0}), ({1}))");

            this.set(Config.ST_Touches, "ST_Touches(({0}), ({1}))");

            this.set(Config.ST_Within, "ST_Within(({0}), ({1}))");

            this.set(Config.ST_Envelope, "ST_Envelope({0})");

            this.set(Config.ST_Intersects, "ST_Intersects(({0}), ({1}))");

            this.set(Config.ST_GeomFromText, "ST_GeomFromText({0}, ({1}))");

            this.set(Config.ST_GeomFromWKB, "ST_GeomFromWKB(({0}), ({1}))");

            this.set(Config.ST_GeomFromEWKB, "ST_GeomFromEWKB(({0}), ({1}))");

            // Por defecto no esta disponible la funcion ST_Simplify

            // El proveedor que la soporte que la defina.

            // this.set(Config.ST_Simplify, "ST_Simplify(({0}), ({1}))");

            this.remove_functionality(Config.ST_Simplify);

            this.set(Config.lcase, "LCASE({0})");

            this.set(Config.ucase, "UCASE({0})");

            this.set(Config.isNull, "( ({0}) IS NULL )");

            this.set(Config.notIsNull, "( ({0}) NOT IS NULL )");

            this.set(Config.operator_not, "( NOT ({0}) )");

            this.set(Config.operator_AND, "{0} AND {1}");

            this.set(Config.operator_OR, "{0} OR {1}");

            this.set(Config.operator_EQ, "( ({0}) = ({1}) )");

            this.set(Config.operator_NE, "( ({0}) <> ({1}) )");

            this.set(Config.operator_GT, "( ({0}) > ({1}) )");

            this.set(Config.operator_GE, "( ({0}) >= ({1}) )");

            this.set(Config.operator_LT, "( ({0}) < ({1}) )");

            this.set(Config.operator_LE, "( ({0}) <= ({1}) )");

            this.set(Config.operator_LIKE, "( ({0}) LIKE ({1}) )");

            this.set(Config.operator_ILIKE, "( ({0}) ILIKE ({1}) )");

            this.set(Config.operator_add, "{0} + {1}");

            this.set(Config.operator_subst, "{0} - {1}");

            this.set(Config.operator_mult, "{0} * {1}");

            this.set(Config.operator_div, "{0} / {1}");

            this.set(Config.operator_concat, "{0} || {1}");

    protected String bytearray_hex(byte[] data) {

    protected String bytearray_0x(byte[] data) {

        return "0x" + bytearray_hex(data);

    }

        return "x'" + bytearray_hex(data) + "'";

    public Function ST_Simplify(Value geom, Value tolerance) {

        return function("ST_Simplify", config.getString(Config.ST_Simplify), tolerance);

    }

    @Override

        private boolean _isIndexed;

            this._isIndexed = false;

        public ColumnDescriptorBuilderBase(String name, int type, int type_p, int type_s, boolean isPk, boolean isIndexed, boolean allowNulls, boolean isAutomatic, Object defaultValue) {

            this._isIndexed = isIndexed;

        public ColumnDescriptorBuilderBase(String name, int geom_type, int geom_subtype, IProjection proj, boolean isIndexed, boolean allowNulls) {

            this.type = DataTypes.GEOMETRY;

            this._isIndexed = isIndexed;

        public boolean isIndexed() {

            return _isIndexed;

        }

        @Override

            if( supportSchemas() ) {

                this.schemaName = name;

            }

            if( !supportSchemas() ) {

                return false;

            }

        public AlterTableBuilder add_column(String columnName, int type, int type_p, int type_s, boolean isPk, boolean isIndexed, boolean allowNulls, boolean isAutomatic, Object defaultValue) {

            this.adds.add(new ColumnDescriptorBuilderBase(columnName, type, type_p, type_s, isPk, isIndexed, allowNulls, isAutomatic, defaultValue));

        public AlterTableBuilder alter_column(String columnName, int type, int type_p, int type_s, boolean isPk, boolean isIndexed, boolean allowNulls, boolean isAutomatic, Object defaultValue) {

            this.alters.add(new ColumnDescriptorBuilderBase(columnName, type, type_p, type_s, isPk, isIndexed, allowNulls, isAutomatic, defaultValue));

        public CreateTableBuilderBase add_column(String columnName, int type, int type_p, int type_s, boolean isPk, boolean isIndexed, boolean allowNulls, boolean isAutomatic, Object defaultValue) {

            this.columns.add(new ColumnDescriptorBuilderBase(columnName, type, type_p, type_s, isPk, isIndexed, allowNulls, isAutomatic, defaultValue));

        public CreateTableBuilder add_geometry_column(String columnName, int type, int subtype, IProjection proj, boolean isIndexed, boolean allowNulls) {

            this.columns.add(new ColumnDescriptorBuilderBase(columnName, type, subtype, proj, isIndexed, allowNulls));

            for (ColumnDescriptorBuilderBase column : columns) {

                if( column.isIndexed() ) {

                    String sql;

                    String name = "idx_" + this.table().getName() + column.getName();

                    if( column.isGeometry() ) {

                        sql = MessageFormat.format(

                            config.getString(SQLConfig.CREATE_INDEX_name_ON_table_USING_GIST_column),

                            name,

                            this.table().toString(),

                            column.getName()

                        );

                    } else {

                        sql = MessageFormat.format(

                            config.getString(SQLConfig.CREATE_INDEX_name_ON_table_column),

                            name,

                            this.table().toString(),

                            column.getName()

                        );

                    }

                    sqls.add(sql);

                }

            }            

        config.set(SQLConfig.DELETE_GEOMETRY_COLUMN_FROM_TABLE_table, "DELETE FROM GEOMETRY_COLUMNS WHERE f_table_name = {0}");

        config.set(SQLConfig.GRANT_privileges_ON_table_TO_role, "GRANT {0} ON {1} TO {2}");        

        config.set(SQLConfig.CREATE_INDEX_name_ON_table_column, "CREATE INDEX {0} ON {1} ({2})");

        config.set(SQLConfig.CREATE_INDEX_name_ON_table_USING_GIST_column, "CREATE INDEX {0} ON {1} USING GIST ({2})");

    @Override

    public boolean supportSchemas() {

        return config.getBoolean(Config.support_schemas);

    }

            sqlgeometrytypes.put( new ImmutablePair<>(Geometry.TYPES.MULTICURVE,Geometry.SUBTYPES.GEOM2D), "MULTILINESTRING");

            sqlgeometrytypes.put( new ImmutablePair<>(Geometry.TYPES.MULTICURVE,Geometry.SUBTYPES.GEOM3D), "MULTILINESTRINGZ");

            sqlgeometrytypes.put( new ImmutablePair<>(Geometry.TYPES.MULTICURVE,Geometry.SUBTYPES.GEOM2DM), "MULTILINESTRINGM");

            sqlgeometrytypes.put( new ImmutablePair<>(Geometry.TYPES.MULTICURVE,Geometry.SUBTYPES.GEOM3DM), "MULTILINESTRINGZM");

            sqlgeometrytypes.put( new ImmutablePair<>(Geometry.TYPES.MULTISURFACE,Geometry.SUBTYPES.GEOM2D), "MULTIPOLYGON");

            sqlgeometrytypes.put( new ImmutablePair<>(Geometry.TYPES.MULTISURFACE,Geometry.SUBTYPES.GEOM3D), "MULTIPOLYGONZ");

            sqlgeometrytypes.put( new ImmutablePair<>(Geometry.TYPES.MULTISURFACE,Geometry.SUBTYPES.GEOM2DM), "MULTIPOLYGONM");

            sqlgeometrytypes.put( new ImmutablePair<>(Geometry.TYPES.MULTISURFACE,Geometry.SUBTYPES.GEOM3DM), "MULTIPOLYGONZM");

                false,

                false,

                false,

        // Los gestores de BBDD no usan indices si se envuelve la columna 

        // geometria con la funcion ST_envelope.

                        // builder.ST_Envelope(builder.column(geomName))

                        builder.column(geomName)

        if( connection==null ) {

            return false;

        }

import java.util.logging.Level;

import org.gvsig.fmap.dal.SQLBuilder;

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

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

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

    private SQLBuilder sqlbuilder;

            this( StringUtils.isEmpty(params.getSchema())? 

                params.getTable() : params.getSchema() + "." + params.getTable(), 

                params);

        if( sqlbuilder.supportSchemas() ) {

            if (schema == null) {

                throw new ExporttoPanelValidationException(

                        i18nManager.getTranslation(

                                "_The_name_of_schema_cannot_be_empty"

                        )

                );

            }

                if ( StringUtils.equals(schema,item.getParams().getSchema())

                        && StringUtils.equals(tablename,item.getParams().getTable())) {

        JDBCServerExplorerParameters explorerParameters = provider.getExplorerParameters();

        if (explorerParameters != null) {

            try {

                DataManager dataManager = DALLocator.getDataManager();

                JDBCServerExplorer explorer = (JDBCServerExplorer) dataManager.openServerExplorer(

                    explorerParameters.getExplorerName(),

                    explorerParameters

                );

                this.sqlbuilder = explorer.createSQLBuilder();

            } catch (Exception ex) {

                throw new RuntimeException("Can't retrieve the sqlbuilder", ex);

            }

        }

                        if( sqlbuilder.supportSchemas() ) {

                            txtSchema.setText(sqlbuilder.default_schema());

                        } else {

                            txtSchema.setText("");

                            txtSchema.setEnabled(false);

                        }