gvSIG data provider for MySQL

package org.gvsig.mysql.dal.operations;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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.operations.FetchFeatureTypeOperation;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.type.GeometryType;

public class MySQLFetchFeatureTypeOperation extends FetchFeatureTypeOperation {

    private static Map<String,GeometryType>spatialiteGeometryTypes = null;

    public MySQLFetchFeatureTypeOperation(

            JDBCHelper helper

        ) {

        super(helper);

    }

    private GeometryType getGT(

            GeometryManager manager, 

            int type, 

            int subtype

        ) {

        try {

            return manager.getGeometryType(type, subtype);

        } catch (Exception ex) {

            return null;

        }

    }

    public MySQLFetchFeatureTypeOperation(

            JDBCHelper helper,

            EditableFeatureType featureType,

            String dbname,

            String schema,

            String table,

            List<String> primaryKeys,

            String defaultGeometryColumn,

            IProjection crs

        ) {

        super(helper, featureType, dbname, schema, table, primaryKeys, defaultGeometryColumn, crs);

    }            

    @Override

    public void fetch(EditableFeatureType featureType, Connection conn, String dbname, String schema, String table, List<String> pks, String defaultGeometryColumn, IProjection crs) throws DataException {

        super.fetch(featureType, conn, dbname, schema, table, pks, defaultGeometryColumn, crs);

    }

    @Override

    protected int getDataTypeFromMetadata(

            ResultSetMetaData rsMetadata,

            int colIndex

        ) throws SQLException {

        // En SpatiaLite no existe el tipo de dato Geometria, las geometrias

        // se guardan en un BLOB, y en getColumnTypeName se indica el tipo

        // de la geometria.

        if( rsMetadata.getColumnType(colIndex) != java.sql.Types.BINARY ) {

            return super.getDataTypeFromMetadata(rsMetadata, colIndex);

        }

        String typeName = rsMetadata.getColumnTypeName(colIndex);

        GeometryType gt = getGeometryTypeFromSpatiaLiteTypeName(typeName);

        if( gt==null ) {

            return super.getDataTypeFromMetadata(rsMetadata, colIndex);

        }

        return DataTypes.GEOMETRY;

    }

    @Override

    protected void fetchGeometryTypeAndSRS(

            EditableFeatureAttributeDescriptor attr,

            ResultSetMetaData rsMetadata,

            int colIndex

        ) {

        if( attr.getType()!=DataTypes.GEOMETRY ) {

            return;

        }

        try {

            String typeName = rsMetadata.getColumnTypeName(colIndex);

            GeometryType gt = getGeometryTypeFromSpatiaLiteTypeName(typeName);

            if( gt != null ) {

                attr.setGeometryType(gt);

                JDBCSQLBuilderBase sqlbuilder = this.createSQLBuilder();

                sqlbuilder.select().column().name("f_table_name");

                sqlbuilder.select().column().name("f_geometry_column");

                // sqlbuilder.select().column().name("geometry_type");

                sqlbuilder.select().column().name("type");

                sqlbuilder.select().column().name("coord_dimension");

                sqlbuilder.select().column().name("srid");

                // sqlbuilder.select().column().name("spatial_index_enabled");

                sqlbuilder.select().where().set(

                        sqlbuilder.eq(

                                sqlbuilder.column("f_table_name"),

                                sqlbuilder.constant(this.getTablename())

                        )

                );                

                sqlbuilder.select().where().and(

                        sqlbuilder.eq(

                                sqlbuilder.column("f_geometry_column"),

                                sqlbuilder.constant(attr.getName())

                        )

                );         

                sqlbuilder.select().from().table().name("geometry_columns");

                Statement st = null;

                ResultSet rs = null;

                int srsid = -1;

                try {

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

                    rs = JDBCUtils.executeQuery(st, sqlbuilder.toString());

                    if (rs.next()) {

                        srsid = rs.getInt("srid");

                    }

                } catch(Exception ex) {

                    logger.warn("Can't read SRS from DDBB.",ex);

                } finally {

                    JDBCUtils.closeQuietly(rs);

                    JDBCUtils.closeQuietly(st);

                }

                if( srsid > 0 ) {

                    attr.setSRS(this.helper.getProjectionFromSRSId(srsid));

                }

            }

        } catch (SQLException ex) {

            // Do nothing

        }

    }

    private GeometryType getGeometryTypeFromSpatiaLiteTypeName(String typeName) {

        if( spatialiteGeometryTypes==null ) {

            GeometryManager manager = GeometryLocator.getGeometryManager();

            spatialiteGeometryTypes = new HashMap<>();

            spatialiteGeometryTypes.put("POINT", getGT(manager, Geometry.TYPES.POINT,Geometry.SUBTYPES.GEOM2D));

            spatialiteGeometryTypes.put("LINESTRING", getGT(manager, Geometry.TYPES.LINE,Geometry.SUBTYPES.GEOM2D));

            spatialiteGeometryTypes.put("POLYGON", getGT(manager, Geometry.TYPES.POLYGON,Geometry.SUBTYPES.GEOM2D));

            spatialiteGeometryTypes.put("MULTIPOINT", getGT(manager, Geometry.TYPES.MULTIPOINT,Geometry.SUBTYPES.GEOM2D));

            spatialiteGeometryTypes.put("MULTILINESTRING", getGT(manager, Geometry.TYPES.MULTILINE,Geometry.SUBTYPES.GEOM2D));

            spatialiteGeometryTypes.put("MULTIPOLYGON", getGT(manager, Geometry.TYPES.MULTIPOLYGON,Geometry.SUBTYPES.GEOM2D));

            spatialiteGeometryTypes.put("GEOMETRY", getGT(manager, Geometry.TYPES.GEOMETRY,Geometry.SUBTYPES.GEOM2D));

        }

        return spatialiteGeometryTypes.get(typeName);

    }

}

package org.gvsig.mysql.dal.operations;

import java.util.List;

import org.cresques.cts.IProjection;

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

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

import org.gvsig.fmap.dal.store.jdbc2.spi.operations.CalculateEnvelopeOfColumnOperation;

import org.gvsig.fmap.dal.store.jdbc2.spi.operations.FetchFeatureTypeOperation;

import org.gvsig.fmap.dal.store.jdbc2.spi.operations.OperationsFactoryBase;

import org.gvsig.fmap.geom.primitive.Envelope;

public class MySQLOperationsFactory extends OperationsFactoryBase {

    public MySQLOperationsFactory(JDBCHelper helper) {

        super(helper);

    }

    @Override

    public FetchFeatureTypeOperation createFetchFeatureType(EditableFeatureType type, String database, String schema, String table, List<String> primaryKeys, String defaultGeometryField, IProjection crs) {

        return new MySQLFetchFeatureTypeOperation(helper, type, database, schema, table, primaryKeys, defaultGeometryField, crs);

    }

    @Override

    public CalculateEnvelopeOfColumnOperation createCalculateEnvelopeOfColumn(String subquery, String database, String schema, String table, String columnName, String baseFilter, Envelope workingArea, IProjection crs) {

        return new MySQLCalculateEnvelopeOfColumnOperation(helper, subquery, table, schema, table, columnName, baseFilter, workingArea, crs);

    }

}

package org.gvsig.mysql.dal.operations;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.Statement;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

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

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

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.operations.CalculateEnvelopeOfColumnOperation;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.primitive.Envelope;

public class MySQLCalculateEnvelopeOfColumnOperation extends CalculateEnvelopeOfColumnOperation {

    public MySQLCalculateEnvelopeOfColumnOperation(JDBCHelper helper, String subquery, String dbName, String schemaName, String tableName, String columnName, String baseFilter, Envelope limit, IProjection crs) {

        super(helper, subquery, dbName, schemaName, tableName, columnName, baseFilter, limit, crs);

    }

    @Override

    public Envelope calculateEnvelopeOfColumn(

            Connection conn,

            String subquery,

            String dbName,

            String schemaName,

            String tableName,

            String columnName,

            String baseFilter,

            Envelope limit,

            IProjection crs

    ) throws DataException {

        //

        // MySQL no soporta la funcion de agregado ST_Extent

        //

        JDBCSQLBuilderBase sqlbuilder = this.createSQLBuilder();

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

            sqlbuilder.getAsGeometry(

                sqlbuilder.ST_Envelope(

                        sqlbuilder.column(columnName)

                )

            )

        );

        if (StringUtils.isEmpty(subquery)) {

            sqlbuilder.select().from().table().database(dbName).schema(schemaName).name(tableName);

        } else {

            sqlbuilder.select().from().subquery(subquery);

        }

        if (StringUtils.isEmpty(baseFilter)) {

            if (limit != null) {

                sqlbuilder.select().where().set(

                        sqlbuilder.ST_Intersects(

                                sqlbuilder.ST_Envelope(

                                        sqlbuilder.column(columnName)

                                ),

                                sqlbuilder.ST_Envelope(

                                        sqlbuilder.geometry(limit.getGeometry(), crs)

                                )

                        )

                );

            }

        } else {

            sqlbuilder.select().where().set( sqlbuilder.custom(baseFilter) );

            if (limit != null) {

                sqlbuilder.select().where().and(

                        sqlbuilder.ST_Intersects(

                            sqlbuilder.ST_Envelope(

                                    sqlbuilder.column(columnName)

                            ),

                            sqlbuilder.ST_Envelope(

                                    sqlbuilder.geometry(limit.getGeometry(), crs)

                            )

                        )

                );

            }

        }

        String sql = sqlbuilder.select().toString();

        Statement st = null;

        ResultSet rs = null;

        try {

            st = conn.createStatement();

            rs = JDBCUtils.executeQuery(st, sql);

            Envelope env = GeometryLocator.getGeometryManager().createEnvelope(Geometry.SUBTYPES.GEOM2D);

            while( rs.next() ) { 

                Geometry geom = this.helper.getGeometryFromColumn(rs, 1);

                if (geom != null) {

                    env.add(geom);

                }

            }

            return env;

        } catch (Exception ex) {

            throw new JDBCSQLException(ex);

        } finally {

            JDBCUtils.closeQuietly(st);

            JDBCUtils.closeQuietly(rs);

        }

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2016 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 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.

 *

 */

package org.gvsig.mysql.dal;

import java.sql.Connection;

import java.sql.SQLException;

import java.text.MessageFormat;

import org.apache.commons.dbcp.BasicDataSource;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.SQLBuilder;

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

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

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

import org.gvsig.mysql.dal.operations.MySQLOperationsFactory;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class MySQLHelper extends JDBCHelperBase {

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

    public static final String NAME = "MySQL";

    public static final String MySQLJDBCDriver = "com.mysql.jdbc.Driver";

    public static String getConnectionURL(MySQLConnectionParameters params) {

        String connectionURL = MessageFormat.format(

                "jdbc:mysql://{0}:{1,number,#}/{2}",

                params.getHost(),

                params.getPort(),

                params.getDBName()

        );

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

        return connectionURL;

    }

    private static class ConnectionProvider {

        private static boolean needRegisterDriver = true;

        private BasicDataSource dataSource = null;

        private final MySQLConnectionParameters connectionParameters;

        public ConnectionProvider(MySQLConnectionParameters connectionParameters) {

            this.connectionParameters = connectionParameters;

        }

        public Connection getConnection() throws SQLException {

            if (this.dataSource == null) {

                this.dataSource = this.createDataSource();               

            }

            Connection conn = this.dataSource.getConnection();

            return conn;

        }

        private BasicDataSource createDataSource() throws SQLException {

            if (!this.isRegistered()) {

                this.registerDriver();

            }

            JDBCConnectionParameters params = connectionParameters;

            BasicDataSource dataSource = new BasicDataSource();

            dataSource.setDriverClassName(params.getJDBCDriverClassName());

            dataSource.setUsername(params.getUser());

            dataSource.setPassword(params.getPassword());

            dataSource.setUrl(params.getUrl());

            dataSource.setMaxWait(60L * 1000);

            return dataSource;

        }

        private boolean isRegistered() {

            return needRegisterDriver;

        }

        public void registerDriver() throws SQLException {

            String className = this.connectionParameters.getJDBCDriverClassName();

            if (className == null) {

                return;

            }

            try {

                Class theClass = Class.forName(className);

                if (theClass == null) {

                    throw new JDBCDriverClassNotFoundException(MySQLLibrary.NAME, className);

                }

            } catch (Exception e) {

                throw new SQLException("Can't register JDBC driver '" + className + "'.", e);

            }

            needRegisterDriver = false;

        }

    }

    private ConnectionProvider connectionProvider = null;

    public MySQLHelper(JDBCConnectionParameters connectionParameters) {

        super(connectionParameters);

    }

    @Override

    public Connection getConnection() throws AccessResourceException {

        try {

            if (this.connectionProvider == null) {

                this.connectionProvider = new ConnectionProvider(this.getConnectionParameters());

            }

            return this.connectionProvider.getConnection();

        } catch (SQLException ex) {

            throw new AccessResourceException(MySQLLibrary.NAME, ex);

        }

    }

    @Override

    public MySQLConnectionParameters getConnectionParameters() {

        return (MySQLConnectionParameters) super.getConnectionParameters();

    }

    @Override

    public String getConnectionURL() {

        return getConnectionURL(this.getConnectionParameters());

    }

    @Override

    protected String getResourceType() {

        return MySQLLibrary.NAME;

    }

    @Override

    public String getProviderName() {

        return MySQLLibrary.NAME;

    }

    @Override

    public JDBCSQLBuilderBase createSQLBuilder() {

        return new MySQLSQLBuilder(this);

    }

    @Override

    public OperationsFactory getOperations() {

        if (this.operationsFactory == null) {

            this.operationsFactory = new MySQLOperationsFactory(this);

        }

        return operationsFactory;

    }

    @Override

    public SQLBuilder.GeometrySupportType getGeometrySupportType() {

        return SQLBuilder.GeometrySupportType.WKB;

    }

    @Override

    public boolean hasSpatialFunctions() {

        return true;

    }

    @Override

    public boolean canWriteGeometry(int geometryType, int geometrySubtype) {

        return true;

    }

    @Override

    public String getQuoteForIdentifiers() {

        return "\"";

    }

    @Override

    public boolean allowAutomaticValues() {

        return true;

    }

    @Override

    public boolean supportOffsetInSelect() {

        return true;

    }

    @Override

    public String getQuoteForStrings() {

        return "'";

    }

    @Override

    public int getSRSCode(IProjection crs) {

        // TODO: ir a buscarlo a la BBDD a ver donde puede estar

        return super.getSRSCode(crs);

    }

    @Override

    public IProjection getProjectionFromSRSId(int srsid) {

        // TODO: ir a buscarlo a la BBDD a ver donde puede estar

        return super.getProjectionFromSRSId(srsid);

    }

    @Override

    public String getSourceId(JDBCStoreParameters parameters) {

        return parameters.getDBName() + "." + 

               parameters.getSchema()+ "." + 

               parameters.getTable();

    }

    @Override

    public JDBCNewStoreParameters createNewStoreParameters() {

        return new MySQLNewStoreParameters();

    }

    @Override

    public JDBCStoreParameters createOpenStoreParameters() {

        return new MySQLStoreParameters();

    }

    @Override

    public JDBCServerExplorerParameters createServerExplorerParameters() {

        return new MySQLExplorerParameters();

    }

}

package org.gvsig.mysql.dal;

import org.gvsig.fmap.dal.DataParameters;

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

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

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

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

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

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

import org.gvsig.fmap.dal.store.jdbc2.impl.JDBCStoreProviderFactory;

public class MySQLStoreProviderFactory extends JDBCStoreProviderFactory {

    private static final String NAME = MySQLLibrary.NAME;

    public MySQLStoreProviderFactory() {

        super(

                NAME, 

                "MySQL store"

        );

    }

    @Override

    public JDBCStoreProvider createProvider(

            DataParameters parameters,

            DataStoreProviderServices providerServices

    ) throws InitializeException {

        JDBCHelper helper = new MySQLHelper((JDBCConnectionParameters) parameters);

        JDBCStoreProvider provider = helper.createProvider(

                (JDBCStoreParameters) parameters, 

                providerServices

        );

        return provider;

    }

    @Override

    public JDBCStoreParameters createParameters() {

        JDBCStoreParameters params = new MySQLStoreParameters();

        return params;

    }

}

/* 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.mysql.dal;

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

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

public class MySQLStoreParameters extends JDBCStoreParameters implements MySQLConnectionParameters {

    private final MySQLConnectionParametersHelper helper;

    public MySQLStoreParameters() {

        super(

                MySQLLibrary.NAME + "StoreParameters",

                MySQLLibrary.NAME

        );

        this.helper = new MySQLConnectionParametersHelper(this);

    }

    @Override

    public String getUrl() {

        return this.helper.getUrl();

    }

    @Override

    public void validate() throws ValidateDataParametersException {

        this.helper.validate();

        super.validate();

    }

}

package org.gvsig.mysql.dal;

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

public interface MySQLConnectionParameters extends JDBCConnectionParameters {

}

package org.gvsig.mysql.dal;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DataParameters;

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

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

public class MySQLConnectionParametersHelper {

    private final JDBCConnectionParameters parameters;

    public MySQLConnectionParametersHelper(JDBCConnectionParameters parameters) {

        this.parameters = parameters;

    }

    public String getUrl() {

        String url = (String) this.getDynValue(JDBCConnectionParameters.URL_PARAMTER_NAME);

        if( StringUtils.isEmpty(url) ) {

            url = MySQLHelper.getConnectionURL((MySQLConnectionParameters) this.parameters);

            this.setDynValue(JDBCConnectionParameters.URL_PARAMTER_NAME,url);

        }

        return url;

    }

    public void validate() throws ValidateDataParametersException {

        // Do nothing

    }

    private Object getDynValue(String name) {

        return ((DataParameters)this.parameters).getDynValue(name);

    }

    private void setDynValue(String name, Object value) {

        ((DataParameters)this.parameters).setDynValue(name,value);

    }

}

/* 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.mysql.dal;

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

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

public class MySQLExplorerParameters extends

        JDBCServerExplorerParameters 

    implements

        MySQLConnectionParameters

    {

    private final MySQLConnectionParametersHelper helper;

    public MySQLExplorerParameters() {

        super(

                MySQLLibrary.NAME + "ServerExplorerParameters",

                MySQLLibrary.NAME

        );

        this.helper = new MySQLConnectionParametersHelper(this);

    }

    @Override

    public String getUrl() {

        return this.helper.getUrl();

    }

    @Override

    public void validate() throws ValidateDataParametersException {

        this.helper.validate();

        super.validate();

    }

}

/* 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.mysql.dal;

import org.gvsig.fmap.dal.DALLibrary;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.fmap.dal.store.db.DBHelper;

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

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

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

public class MySQLLibrary extends AbstractLibrary {

    public static final String NAME = "MySQL";

    @Override

    public void doRegistration() {

        registerAsServiceOf(DALLibrary.class);

        require(JDBCLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        LibraryException ex = null;

        DataManagerProviderServices dataman = 

                (DataManagerProviderServices) DALLocator.getDataManager();

        try {

            Class.forName(MySQLHelper.MySQLJDBCDriver);

        } catch(Throwable th) {

            MySQLHelper.logger.warn("Can't load MySQL JDBC Driver.",th);

        }

        DBHelper.registerParametersDefinition(

                NAME + "StoreParameters",

                MySQLStoreParameters.class,

                dataman.getResourceAsStream(this, NAME + "Parameters.xml")

        );

        DBHelper.registerParametersDefinition(

                NAME + "NewStoreParameters",

                MySQLNewStoreParameters.class,

                dataman.getResourceAsStream(this, NAME + "Parameters.xml")

        );

        DBHelper.registerParametersDefinition(

                NAME + "ServerExplorerParameters",

                MySQLExplorerParameters.class,

                dataman.getResourceAsStream(this, NAME + "Parameters.xml")

        );

//        DBHelper.registerParametersDefinition(

//                NAME + "ResourceParameters",

//                MySQLResourceParameters.class,

//                dataman.getResourceAsStream(this, NAME + "Parameters.xml")

//        );

        try {

            DBHelper.registerMetadataDefinition(

                NAME,

                JDBCStoreProviderBase.class,

                dataman.getResourceAsStream(this, NAME + "Metadata.xml")

            );

        } catch (MetadataException e) {

            ex = new LibraryException(this.getClass(), e);

        }

//        ResourceManagerProviderServices resman = (ResourceManagerProviderServices) DALLocator

//                .getResourceManager();

//

//        if (!resman.getResourceProviders().contains(NAME)) {

//            resman.register(NAME,

//                "Resource for " + NAME,

//                MySQLResource.class,

//                MySQLResourceParameters.class

//            );

//        }

        if (!dataman.getStoreProviderRegister().exits(NAME)) {

            dataman.registerStoreProviderFactory(new MySQLStoreProviderFactory());

        }

        if (!dataman.getServerExplorerRegister().exits(NAME)) {

            dataman.registerServerExplorerFactory(new MySQLExplorerFactory());

        }

        if (ex != null) {

            throw ex;

        }

    }

}

package org.gvsig.mysql.dal;

import java.util.ArrayList;

import java.util.List;

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

public class MySQLSQLBuilder extends JDBCSQLBuilderBase {

    private final MySQLHelper helper;

    public MySQLSQLBuilder(MySQLHelper helper) {

        super();

        this.helper = helper;

        //

        // MySQL 5.5, SQL functions reference list

        //

        // https://dev.mysql.com/doc/refman/5.5/en/sql-syntax.html

        // https://dev.mysql.com/doc/refman/5.5/en/using-spatial-data.html

        //

        // https://dev.mysql.com/doc/refman/5.7/en/spatial-function-reference.html

        //

        config.set(SQLConfig.default_schema, "");

        config.set(SQLConfig.quote_for_identifiers, "`");

        config.set(SQLConfig.allowAutomaticValues, true);

        config.set(SQLConfig.geometry_type_support, this.helper.getGeometrySupportType());

        config.set(SQLConfig.has_spatial_functions, this.helper.hasSpatialFunctions());

        config.remove_functionality(SQLConfig.DELETE_GEOMETRY_COLUMN_FROM_TABLE_schema_table);

        config.remove_functionality(SQLConfig.DELETE_GEOMETRY_COLUMN_FROM_TABLE_table);

        // MySQL no tiene funciones de agregado sobre geometrias.

        // Esto no es nada eficiente y fallara con tablas grandes.

        // https://forums.mysql.com/read.php?23,249284,249284#msg-249284

        config.set(SQLConfig.ST_ExtentAggregate, "ST_AsWKB(ST_Envelope(ST_GeomCollFromText(GROUP_CONCAT(ST_AsWKT({0})))))");

        config.set(SQLConfig.ST_UnionAggregate, "null");

        config.set(SQLConfig.UPDATE_TABLE_STATISTICS_table,"ANALYZE TABLE {0}");

        config.set(SQLConfig.lcase, "lower({0})");

        config.set(SQLConfig.ucase, "upper({0})");

        config.set(SQLConfig.operator_ILIKE, "lower({0}) LIKE lower({1})");

        config.set(SQLConfig.isNull, "( ({0}) IS NULL )");

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

        config.set(SQLConfig.type_boolean, "BIT");

        config.set(SQLConfig.type_byte, "TINYINT");

        config.set(SQLConfig.type_bytearray, "BINARY");

        config.set(SQLConfig.type_geometry, "GEOMETRY");

        config.set(SQLConfig.type_char, "TEXT");

        config.set(SQLConfig.type_date, "DATETIME");

        config.set(SQLConfig.type_double, "DOUBLE"); 

        config.set(SQLConfig.type_numeric_p, "DECIMAL({0})");

        config.set(SQLConfig.type_numeric_ps, "DECIMAL({0},{1})");

        config.set(SQLConfig.type_bigdecimal, "DECIMAL");

        config.set(SQLConfig.type_float, "FLOAT");

        config.set(SQLConfig.type_int, "INTEGER");

        config.set(SQLConfig.type_long, "BIGINT");

        config.set(SQLConfig.type_string, "CHAR");

        config.set(SQLConfig.type_string_p, "VARCHAR({0})");

        config.set(SQLConfig.type_time, "TIME");

        config.set(SQLConfig.type_timestamp, "TIMESTAMP");

        config.set(SQLConfig.type_version, "VARCHAR(45)");

        config.set(SQLConfig.type_URI, "TEXT");

        config.set(SQLConfig.type_URL, "TEXT");

        config.set(SQLConfig.type_FILE, "TEXT");

        config.set(SQLConfig.type_FOLDER, "TEXT");        

    }

    public class MySQLTableNameBuilderBase extends TableNameBuilderBase {

        @Override

        public boolean has_schema() {

            return false;

        }

    }

    protected class MySQLCreateTableBuilder extends CreateTableBuilderBase {

        @Override

        public List<String> toStrings() {

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

            StringBuilder builder = new StringBuilder();

            builder.append("CREATE TABLE ");

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

            builder.append(" (");

            boolean first = true;

            for (ColumnDescriptorBuilder column : columns) {

                if (first) {

                    first = false;

                } else {

                    builder.append(", ");

                }

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

                builder.append(" ");

                builder.append(sqltype(column.getType(), column.getPrecision(), column.getSize()));

                if (column.isPrimaryKey()) {

                    builder.append(" PRIMARY KEY");

                }

                if( column.isAutomatic() ) {

                    builder.append(" AUTO_INCREMENT");

                }

                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");

                }

            }

            builder.append(" )");

            sqls.add(builder.toString());

            return sqls;

        }

    }

    public class MySQLSelectBuilderBase 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() {

            // MySQL requiere que si se especifica OFFSET deba especificarse

            // LIMIT obligatoriamente. Se le puede poner un LIMIT -1 cuando 

            // queramos un OFFSET sin especificar un LIMIT.

            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());

            }

            if ( this.has_from() ) {

                builder.append(" FROM ");

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

            }

            if ( this.has_where() ) {

                builder.append(" WHERE ");

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

            }

            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());                    

                }   

            }

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

                builder.append(" LIMIT ");

                builder.append(this.limit);

                builder.append(" OFFSET ");

                builder.append(this.offset);

            } else if ( this.has_limit()) {

                builder.append(" LIMIT ");

                builder.append(this.limit);

            } else if ( this.has_offset() ) {

                // See https://dev.mysql.com/doc/refman/5.7/en/select.html#idm140126933499488

                builder.append(" LIMIT 18446744073709551615 OFFSET ");

                builder.append(this.offset);    

            }

            return builder.toString();

        }

    }

    @Override

    public String bytearray(byte[] data) {

        // MySQL usa un formato diferencte para especificar un array de 

        // bytes. En lugar de 0x... usa x'...' .

        StringBuilder builder = new StringBuilder();

        builder.append("x'");

        for (byte abyte : data) {

            int v = abyte & 0xff;

            builder.append(String.format("%02x", v));

        }

        builder.append("'");

        return builder.toString();

    }

    @Override

    protected TableNameBuilder createTableNameBuilder() {

        return new MySQLTableNameBuilderBase();

    }

    @Override

    protected CreateTableBuilder createCreateTableBuilder() {

        return new MySQLCreateTableBuilder();

    }

    @Override

    protected SelectBuilder createSelectBuilder() {

        return new MySQLSelectBuilderBase();

    }

}

package org.gvsig.mysql.dal;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

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

import org.gvsig.fmap.dal.spi.DataServerExplorerProviderServices;

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

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

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

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

import org.gvsig.fmap.dal.store.jdbc2.impl.JDBCServerExplorerFactory;

public class MySQLExplorerFactory extends JDBCServerExplorerFactory {

    private static final String NAME = MySQLLibrary.NAME;

    public MySQLExplorerFactory() {

        super(

                NAME,

                "MySQL Server"

        );

    }

    @Override

    public JDBCServerExplorer create(

            DataServerExplorerParameters parameters, 

            DataServerExplorerProviderServices providerServices

        ) throws InitializeException {

        JDBCHelper helper = new MySQLHelper((JDBCConnectionParameters) parameters);

        JDBCServerExplorer server = helper.createServerExplorer(

                (JDBCServerExplorerParameters) parameters, 

                providerServices

        );

        return server;

    }

    @Override

    public JDBCServerExplorerParameters createParameters() {

        JDBCServerExplorerParameters params = new MySQLExplorerParameters();

        return params;    

    }

}

/* 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.mysql.dal;

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

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

public class MySQLNewStoreParameters 

    extends 

        JDBCNewStoreParameters 

    implements 

        MySQLConnectionParameters 

    {

    private final MySQLConnectionParametersHelper helper;

    public MySQLNewStoreParameters() {

        super(

            MySQLLibrary.NAME + "NewStoreParameters", 

            MySQLLibrary.NAME

        );

        this.helper = new MySQLConnectionParametersHelper(this);

    }

    @Override

    public String getUrl() {

        return this.helper.getUrl();

    }

    @Override

    public void validate() throws ValidateDataParametersException {

        this.helper.validate();

    }

}

org.gvsig.mysql.dal.MySQLLibrary

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

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

      <extends>

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

      </extends>

      <description>Metadata for MySQL</description>

      <fields>

      </fields>

    </class>

  </classes>

</definitions>  

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="MySQLResourceParameters">

      <extends>

        <class>JDBC2ResourceParameters</class>

      </extends>

      <fields>

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

          defaultValue="com.mysql.jdbc.Driver" group="Advanced">

          <description>JDBC driver class for MySQL</description>

        </field>

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

          defaultValue="3306" group="Connection" hidden="false">

          <description></description>

        </field>

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

            defaultValue="localhost" group="Connection" hidden="false">

          <description></description>

        </field>

        <field name="dbname" type="string" mandatory="true" hidden="false" defaultValue="" group="Basic">

          <description></description>

        </field>

        <field name="schema" type="string" mandatory="false" hidden="true" defaultValue="" group="Basic">

          <description></description>

        </field>

        <field name="catalog" type="string" mandatory="false" hidden="true" defaultValue="" group="Basic">

          <description></description>

        </field>

        <field name="url" type="string" mandatory="false" hidden="false" defaultValue="" group="Basic">

          <description></description>

        </field>

        <field name="dbuser" type="string" mandatory="false" defaultValue="" group="Basic">

          <description></description>

        </field>

        <field name="password" type="string" mandatory="false" defaultValue="" group="Basic">

          <description></description>

        </field>           

      </fields>

    </class>

    <class name="MySQLStoreParameters">

      <extends>

        <class>JDBC2StoreParameters</class>

        <class>MySQLResourceParameters</class>

      </extends>

      <fields/>

    </class>

    <class name="MySQLNewStoreParameters">

      <extends>

        <class>JDBC2NewStoreParameters</class>

        <class>MySQLResourceParameters</class>

      </extends>

      <fields/>

    </class>

    <class name="MySQLServerExplorerParameters">

      <extends>

        <class>MySQLResourceParameters</class>

        <class>JDBC2ServerExplorerParameters</class>

      </extends>

      <fields/>

    </class>

  </classes>

</definitions>  

package org.gvsig.mysql.dal;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.lang3.ArrayUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.ExpressionBuilder;

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

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

import org.gvsig.fmap.dal.SQLBuilder;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.fmap.dal.store.db.DBHelper;

import org.gvsig.fmap.geom.DataTypes;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.primitive.Polygon;

import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;

public class MySQLSQLBuilderTest extends AbstractLibraryAutoInitTestCase {

    private MySQLHelper helper;

    @Override

    protected void doSetUp() throws Exception {

        DataManagerProviderServices dataman = 

                (DataManagerProviderServices) DALLocator.getDataManager();

        DBHelper.registerParametersDefinition(

                MySQLLibrary.NAME + "StoreParameters",

                MySQLStoreParameters.class,

                dataman.getResourceAsStream(this, MySQLLibrary.NAME + "Parameters.xml")

        );

        MySQLStoreParameters params = new MySQLStoreParameters();

        params.setDBName("test.sqlite");

        params.setTable("test1");

        helper = new MySQLHelper(params);

    }

    List<String> getVariableNames(ExpressionBuilder builder) {

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

        for (Variable var : builder.getVariables()) {

            vars.add(var.getName());

        }

        return vars;

    }

    List<String> getParameterNames(ExpressionBuilder builder) {

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

        for (Parameter param : builder.getParameters()) {

            String s;

            switch(param.getType()) {

                case Constant:

                    Object value = param.getValue();

                    if( value==null ) {

                        s = "null";

                    } else if( value instanceof String ) {

                        s = "'" + (String)value + "'";

                    } else {

                        s = value.toString();

                    }    

                    break;

                case Geometry:

                case Variable:

                default:

                    s = "\"" + param.getName() + "\"";

            }

            params.add(s);

        }

        return params;

    }

    public SQLBuilder createSQLBuilder() {

        return new MySQLSQLBuilder(helper);

    }

    public void testCalulateEnvelope() throws Exception {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        IProjection proj = CRSFactory.getCRS("EPSG:4326");

        Polygon limit = geometryManager.createPolygon(Geometry.SUBTYPES.GEOM2D);

        limit.addVertex(0, 0);

        limit.addVertex(0, 100);

        limit.addVertex(100, 100);

        limit.addVertex(100, 0);

        limit.addVertex(0, 0);

        SQLBuilder builder = createSQLBuilder();

        builder.select().column().value(

            builder.getAsGeometry(

              builder.ST_ExtentAggregate(

                builder.column("the_geom")

              )

            )

        ).as("envelope");

        builder.select().from().table().database("master").schema("dbo").name("test1");

        builder.select().where().set(

            builder.ST_Intersects(

                builder.ST_Envelope(

                    builder.column("the_geom")

                ),

                builder.geometry(limit, proj)

            )

        );

        builder.select().where().and(

                builder.custom("x = 27").add( builder.variable("x") )

        );

        System.out.println("# Test:: testCalulateEnvelope");

        System.out.println("# SQL:: " + builder.toString());

        System.out.println("# Variables:: " + ArrayUtils.toString(getVariableNames(builder)));

        System.out.println("# Parametros:: " + ArrayUtils.toString(getParameterNames(builder)));

        //# Test:: testCalulateEnvelope

        //# SQL:: SELECT ST_AsBinary(Extent("the_geom")) AS "envelope" FROM "test1" WHERE ST_Intersects((ST_Envelope("the_geom")), (ST_GeomFromWKB((x'000000000300000001000000050000000000000000000000000000000000000000000000004059000000000000405900000000000040590000000000004059000000000000000000000000000000000000000000000000000000000000'), (4326)))) AND x = 27

        //# Variables:: [the_geom, x]

        //# Parametros:: []  

        assertEquals(

                "SELECT ST_AsBinary(Extent(\"the_geom\")) AS \"envelope\" FROM \"test1\" WHERE ST_Intersects((ST_Envelope(\"the_geom\")), (ST_GeomFromWKB((x'000000000300000001000000050000000000000000000000000000000000000000000000004059000000000000405900000000000040590000000000004059000000000000000000000000000000000000000000000000000000000000'), (4326)))) AND x = 27",