gvSIG data provider for MySQL

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <artifactId>org.gvsig.mysql</artifactId>

    <version>2.4.16</version>

    <packaging>pom</packaging>

    <name>${project.artifactId}</name>

    <description>MySQL support for DAL and gvSIG</description>

    <parent>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.desktop</artifactId>

        <version>2.0.209</version>

    </parent>

    <url>https://devel.gvsig.org/redmine/projects/gvsig-mysql</url>

    <scm>

        <connection>scm:svn:https://devel.gvsig.org/svn/gvsig-mysql/tags/org.gvsig.mysql-2.4.16</connection>

        <developerConnection>scm:svn:https://devel.gvsig.org/svn/gvsig-mysql/tags/org.gvsig.mysql-2.4.16</developerConnection>

        <url>https://devel.gvsig.org/redmine/projects/gvsig-mysql/repository/show/tags/org.gvsig.mysql-2.4.16</url>

    </scm>

    <repositories>

        <repository>

            <id>gvsig-public-http-repository</id>

            <name>gvSIG maven public HTTP repository</name>

            <url>http://devel.gvsig.org/m2repo/j2se</url>

            <releases>

                <enabled>true</enabled>

                <updatePolicy>daily</updatePolicy>

                <checksumPolicy>warn</checksumPolicy>

            </releases>

            <snapshots>

                <enabled>true</enabled>

                <updatePolicy>daily</updatePolicy>

                <checksumPolicy>warn</checksumPolicy>

            </snapshots>

        </repository>

    </repositories>

    <build>

        <plugins>

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-release-plugin</artifactId>

                <configuration>

                    <tagBase>https://devel.gvsig.org/svn/gvsig-mysql/tags/</tagBase>

                    <goals>deploy</goals>

                </configuration>

            </plugin>

        </plugins>

    </build>

    <dependencyManagement>

        <dependencies>

            <dependency>

                <groupId>org.gvsig</groupId>

                <artifactId>org.gvsig.mysql.provider</artifactId>

                <version>2.4.16</version>

            </dependency>

            <dependency>

                <groupId>org.gvsig</groupId>

                <artifactId>org.gvsig.mysql.app.mainplugin</artifactId>

                <version>2.4.16</version>

            </dependency>

            <dependency>

              <groupId>mysql</groupId>

              <artifactId>mysql-connector-java</artifactId>

              <version>6.0.6</version>

            </dependency>

        </dependencies>

    </dependencyManagement>

    <modules>

        <module>org.gvsig.mysql.app</module>

        <module>org.gvsig.mysql.provider</module>

    </modules>

</project>

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",

                builder.toString()

        );

        assertEquals(

                "[the_geom, x]",

                ArrayUtils.toString(getVariableNames(builder))

        );

        assertEquals(

                "[]",

                ArrayUtils.toString(getParameterNames(builder))

        );

    }

    public void testCount() throws Exception {

        SQLBuilder builder = createSQLBuilder();

        builder.select().column().value(builder.count().all());

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

        builder.select().from().subquery(null);

        builder.select().where().set( builder.custom("pp = 200").add(builder.variable("pp")));

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

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

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

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

        //# Test:: testCount

        //# SQL:: SELECT COUNT(*) FROM "test1" WHERE pp = 200

        //# Variables:: [pp]

        //# Parametros:: []

        assertEquals(

                "SELECT COUNT(*) FROM \"test1\" WHERE pp = 200",

                builder.toString()

        );

        assertEquals(

                "[pp]",

                ArrayUtils.toString(getVariableNames(builder))

        );

        assertEquals(

                "[]",

                ArrayUtils.toString(getParameterNames(builder))

        );

    }

    public void testUpdateStatistics() throws Exception {

        SQLBuilder builder = createSQLBuilder();

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

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

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

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

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

        //# Test:: testUpdateStatistics

        //# SQL:: SELECT UpdateLayerStatistics("test1")

        //# Variables:: []

        //# Parametros:: []

        assertEquals(

                "SELECT UpdateLayerStatistics(\"test1\")",

                builder.toString()

        );

        assertEquals(

                "[]",

                ArrayUtils.toString(getVariableNames(builder))

        );

        assertEquals(

                "[]",

                ArrayUtils.toString(getParameterNames(builder))

        );

    }

    public void testCreateTable() throws Exception {

        SQLBuilder builder = createSQLBuilder();

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

        builder.create_table().add_column(

                "name",

                DataTypes.STRING,

                45,

                0,

                false,

                false,

                true,

                false,

                null

        );

        builder.create_table().add_column(

                "id",

                DataTypes.INT,

                0,

                0,

                true,

                false,

                false,

                true,

                0

        );

        builder.create_table().add_column(

                "geom",

                DataTypes.GEOMETRY,

                0,

                0,

                false,

                false,

                true,

                false,

                null

        );

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

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

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

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

        //# Test:: testCreateTable

        //# SQL:: CREATE TABLE "test1" ("name" TEXT DEFAULT NULL NULL, "id" INTEGER PRIMARY KEY AUTOINCREMENT DEFAULT '0' NOT NULL ); SELECT AddGeometryColumn("test1" , "geom" , -1 , 'GEOMETRY' , 'XYZ', 1)

        //# Variables:: []

        //# Parametros:: []

        assertEquals(

                "CREATE TABLE \"test1\" (\"name\" TEXT DEFAULT NULL NULL, \"id\" INTEGER PRIMARY KEY AUTOINCREMENT DEFAULT '0' NOT NULL ); SELECT AddGeometryColumn(\"test1\" , \"geom\" , -1 , 'GEOMETRY' , 'XYZ', 1)",

                builder.toString()

        );

        assertEquals(

                "[]",

                ArrayUtils.toString(getVariableNames(builder))

        );

        assertEquals(

                "[]",

                ArrayUtils.toString(getParameterNames(builder))

        );

    }

    public void testDropTable() throws Exception {

        SQLBuilder builder = createSQLBuilder();

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

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

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

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

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

        //# Test:: testDropTable

        //# SQL:: DROP TABLE [master].[dbo].[test1]

        //# Variables:: []

        //# Parametros:: []

        assertEquals(

                "DROP TABLE [master].[dbo].[test1]",

                builder.toString()

        );

        assertEquals(

                "[]",

                ArrayUtils.toString(getVariableNames(builder))

        );

        assertEquals(

                "[]",

                ArrayUtils.toString(getParameterNames(builder))

        );

    }

    public void testFetchFeatureProviderByReference() throws Exception {

        SQLBuilder builder = createSQLBuilder();

        String value = "yoyo";

        builder.select().column().name("name");

        builder.select().column().name("id");

        builder.select().column().name("geom").as_geometry();

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

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

            builder.eq(

                builder.column("name"),

                builder.parameter(value).as_constant()

            )

        );

        builder.select().limit(1);

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

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

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

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

        //# Test:: testFetchFeatureProviderByReference

        //# SQL:: SELECT TOP 1 [name], [id], ([geom]).STAsBinary() FROM [master].[dbo].[test1] WHERE ( ([name]) = (?) )

        //# Variables:: [geom, id, name]

        //# Parametros:: ['yoyo']

        assertEquals(

                "SELECT TOP 1 [name], [id], ([geom]).STAsBinary() FROM [master].[dbo].[test1] WHERE ( ([name]) = (?) )",

                builder.toString()

        );

        assertEquals(

                "[geom, id, name]",

                ArrayUtils.toString(getVariableNames(builder))

        );

        assertEquals(

                "['yoyo']",

                ArrayUtils.toString(getParameterNames(builder))

        );

    }

    public void testIsNull() throws Exception {

        SQLBuilder builder = createSQLBuilder();

        builder.select().column().name("name");

        builder.select().column().name("id");

        builder.select().column().name("geom").as_geometry();

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

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

            builder.and(

                builder.isNull(

                    builder.column("name")

                ),

                builder.notIsNull(

                        builder.column("id")

                )

            )

        );

        builder.select().limit(2);

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

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

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

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

        //# Test:: testIsNull

        //# SQL:: SELECT TOP 2 [name], [id], ([geom]).STAsBinary() FROM [master].[dbo].[test1] WHERE ( ([name]) IS NULL ) AND ( ([id]) NOT IS NULL )

        //# Variables:: [geom, id, name]

        //# Parametros:: []

        assertEquals(

                "SELECT TOP 2 [name], [id], ([geom]).STAsBinary() FROM [master].[dbo].[test1] WHERE ( ([name]) IS NULL ) AND ( ([id]) NOT IS NULL )",

                builder.toString()

        );

        assertEquals(

                "[geom, id, name]",

                ArrayUtils.toString(getVariableNames(builder))

        );

        assertEquals(

                "[]",

                ArrayUtils.toString(getParameterNames(builder))

        );

    }

    public void testFetchFeatureType() throws Exception {

        SQLBuilder builder = createSQLBuilder();

        builder.select().column().all();

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

        builder.select().limit(1);

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

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

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

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

        //# Test:: testFetchFeatureType

        //# SQL:: SELECT TOP 1 * FROM [master].[dbo].[test1]

        //# Variables:: []

        //# Parametros:: []

        assertEquals(

                "SELECT TOP 1 * FROM [master].[dbo].[test1]",

                builder.toString()

        );

        assertEquals(

                "[]",

                ArrayUtils.toString(getVariableNames(builder))

        );

        assertEquals(

                "[]",

                ArrayUtils.toString(getParameterNames(builder))

        );

    }

    public void testPerformDeletes() throws Exception {

        SQLBuilder builder = createSQLBuilder();

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

        builder.delete().where().and(

            builder.eq( 

                builder.column("id1"),

                builder.parameter("id1").as_variable()

            )

        );

        builder.delete().where().and(

            builder.eq( 

                builder.column("id2"),

                builder.parameter("id2").as_variable()

            )

        );

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

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

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

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

        //# Test:: testPerformDeletes

        //# SQL:: DELETE FROM [master].[dbo].[test1] WHERE ( ([id1]) = (?) ) AND ( ([id2]) = (?) )

        //# Variables:: [id1, id2]

        //# Parametros:: ["id1", "id2"]

        assertEquals(

                "DELETE FROM [master].[dbo].[test1] WHERE ( ([id1]) = (?) ) AND ( ([id2]) = (?) )",

                builder.toString()

        );

        assertEquals(

                "[id1, id2]",

                ArrayUtils.toString(getVariableNames(builder))

        );

        assertEquals(

                "[\"id1\", \"id2\"]",

                ArrayUtils.toString(getParameterNames(builder))

        );

    }

    public void testPerformInserts1() throws Exception {

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

        SQLBuilder builder = createSQLBuilder();

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

        builder.insert().column().name("id").with_value(builder.parameter("id"));

        builder.insert().column().name("name").with_value(builder.parameter("name"));

        builder.insert().column().name("geom").with_value(builder.parameter("geom").as_geometry_variable().srs(builder.parameter().srs(proj)));

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

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

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

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

        //# Test:: testPerformInserts1

        //# SQL:: INSERT INTO [master].[dbo].[test1] ( [id], [name], [geom] ) VALUES ( ?, ?, geometry::STGeomFromWKB(?, 4326) )

        //# Variables:: [geom, id, name]

        //# Parametros:: ["id", "name", "geom"]

        assertEquals(

                "INSERT INTO [master].[dbo].[test1] ( [id], [name], [geom] ) VALUES ( ?, ?, geometry::STGeomFromWKB(?, 4326) )",

                builder.toString()

        );

        assertEquals(

                "[geom, id, name]",

                ArrayUtils.toString(getVariableNames(builder))

        );

        assertEquals(

                "[\"id\", \"name\", \"geom\"]",

                ArrayUtils.toString(getParameterNames(builder))

        );

    }

    public void testPerformInserts2() throws Exception {

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

        SQLBuilder builder = createSQLBuilder();

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

        builder.insert().column().name("id").with_value(builder.parameter("id"));

        builder.insert().column().name("name").with_value(builder.parameter("name"));

        builder.insert().column().name("geom").with_value(builder.parameter("geom").as_geometry_variable().srs(builder.parameter().srs(proj)));

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

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

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

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

        //# Test:: testPerformInserts2

        //# SQL:: INSERT INTO [master].[dbo].[test1] ( [id], [name], [geom] ) VALUES ( ?, ?, geometry::STGeomFromWKB(?, ?) )

        //# Variables:: [geom, id, name]

        //# Parametros:: ["id", "name", "geom", 4326]

        assertEquals(

                "INSERT INTO [master].[dbo].[test1] ( [id], [name], [geom] ) VALUES ( ?, ?, geometry::STGeomFromWKB(?, ?) )",

                builder.toString()

        );

        assertEquals(

                "[geom, id, name]",

                ArrayUtils.toString(getVariableNames(builder))

        );

        assertEquals(

                "[\"id\", \"name\", \"geom\", 4326]",

                ArrayUtils.toString(getParameterNames(builder))

        );

    }

    public void testPerformUpdates() throws Exception {

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

        SQLBuilder builder = createSQLBuilder();

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

        builder.update().where().and(

            builder.eq(

                builder.column("id"), 

                builder.parameter("id").as_variable()

            )

        );

        builder.update().column().name("name").with_value(builder.parameter("name"));

        builder.update().column().name("geom").with_value(

            builder.parameter("geom").as_geometry_variable().srs(builder.parameter().srs(proj))

        );

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

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

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

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

        //# Test:: testPerformUpdates

        //# SQL:: UPDATE [master].[dbo].[test1] SET [name] = ?, [geom] = geometry::STGeomFromWKB(?, ?) WHERE ( ([id]) = (?) )

        //# Variables:: [geom, id, name]

        //# Parametros:: ["name", "geom", 4326, "id"]

        assertEquals(

                "UPDATE [master].[dbo].[test1] SET [name] = ?, [geom] = geometry::STGeomFromWKB(?, ?) WHERE ( ([id]) = (?) )",

                builder.toString()

        );

        assertEquals(

                "[geom, id, name]",

                ArrayUtils.toString(getVariableNames(builder))

        );

        assertEquals(

                "[\"name\", \"geom\", 4326, \"id\"]",

                ArrayUtils.toString(getParameterNames(builder))

        );

    }

}

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

        }

    }

}

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.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>mySQLGeometryTypes = 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 {

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

            return super.getDataTypeFromMetadata(rsMetadata, colIndex);

        }

        String typeName = rsMetadata.getColumnTypeName(colIndex);

        GeometryType gt = getGeometryTypeFromMySQLTypeName(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 = getGeometryTypeFromMySQLTypeName(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 getGeometryTypeFromMySQLTypeName(String typeName) {

        if( mySQLGeometryTypes==null ) {

            GeometryManager manager = GeometryLocator.getGeometryManager();

            mySQLGeometryTypes = new HashMap<>();

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

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

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

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

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

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

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

        }

        return mySQLGeometryTypes.get(typeName);

    }

}

/* 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);

        }