Application: gvSIG desktop

		<!-- mysql -->

		<mysql-jarIncludes>org/gvsig/fmap/dal/store/mysql/**/**</mysql-jarIncludes>

		<mysql-jarExcludes>NONE</mysql-jarExcludes>

					<exclude>${mysql-jarIncludes}</exclude>

					<!--

						Generates a jar file only with the DAL MySQL Store classes

					-->

					<execution>

						<id>mysql</id>

						<phase>package</phase>

						<goals>

							<goal>jar</goal>

						</goals>

						<configuration>

							<classifier>store.mysql</classifier>

							<includes>

								<include>${mysql-jarIncludes}</include>

							</includes>

							<excludes>

								<exclude>${mysql-jarExcludes}</exclude>

							</excludes>

						</configuration>

					</execution>

			<!-- PostgreSQL and MySQL is needed to run the tests -->

/* 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.

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

package org.gvsig.fmap.dal.store.mysql;

import org.cresques.ProjectionLibrary;

import org.cresques.impl.CresquesCtsLibrary;

import org.gvsig.fmap.dal.DALDbLibrary;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

import org.gvsig.fmap.dal.index.spatial.jts.JTSIndexLibrary;

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

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

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

import org.gvsig.fmap.geom.impl.DefaultGeometryLibrary;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.persistence.xmlentity.XMLEntityManager;

public class MySQLTestWrite extends BaseTestEditableFeatureStore {

	private MySQLNewStoreParameters newParams;

	private MySQLServerExplorer myExplorer;

	protected void setUp() throws Exception {

		super.setUp();

		ToolsLocator.registerDefaultPersistenceManager(XMLEntityManager.class);

		DefaultGeometryLibrary defGeomLib = new DefaultGeometryLibrary();

		defGeomLib.initialize();

		ProjectionLibrary projLib = new ProjectionLibrary();

		projLib.initialize();

		CresquesCtsLibrary cresquesLib = new CresquesCtsLibrary();

		cresquesLib.initialize();

		DALDbLibrary libDb = new DALDbLibrary();

		libDb.initialize();

		DBStoreLibrary libDbStore = new DBStoreLibrary();

		libDbStore.initialize();

		JDBCLibrary libJDBC = new JDBCLibrary();

		libJDBC.initialize();

		MySQLLibrary libMySQL = new MySQLLibrary();

		libMySQL.initialize();

		JTSIndexLibrary jtsIndex = new JTSIndexLibrary();

		jtsIndex.initialize();

		projLib.postInitialize();

		cresquesLib.postInitialize();

		defGeomLib.postInitialize();

		libDb.postInitialize();

		libDbStore.postInitialize();

		libJDBC.postInitialize();

		libMySQL.postInitialize();

		jtsIndex.postInitialize();

	}

	public DataStoreParameters getDefaultDataStoreParameters()

			throws DataException {

		MySQLStoreParameters parameters = null;

		parameters = (MySQLStoreParameters) dataManager

				.createStoreParameters(MySQLStoreProvider.NAME);

		parameters.setHost("localhost");

		parameters.setPort(3306);

		parameters.setUser("test");

		parameters.setPassword("test");

		parameters.setDBName("gis");

		// parameters.setTable("alfanum_autoid");

		parameters.setTable("comunic_lin_300k");

		return parameters;

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see org.gvsig.fmap.dal.feature.BaseTestFeatureStore#hasExplorer()

	 */

	@Override

	public boolean hasExplorer() {

		// TODO Auto-generated method stub

		return true;

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see org.gvsig.fmap.dal.feature.BaseTestFeatureStore#usesResources()

	 */

	@Override

	public boolean usesResources() {

		// TODO Auto-generated method stub

		return true;

	}

	/*

	public void testImportDB() throws Exception {

		JDBCNewStoreParameters newParasm = (JDBCNewStoreParameters) getDefaultNewDataStoreParameters();

		JDBCServerExplorerParameters seParams = (JDBCServerExplorerParameters) dataManager

				.createServerExplorerParameters(JDBCServerExplorer.NAME);

		assertTrue(myExplorer.add(newParasm, true));

		FeatureStore store = (FeatureStore) dataManager

				.createStore(getDefaultDataStoreParameters());

		FeatureStore newstore = (FeatureStore) dataManager

				.createStore(newParasm);

		newstore.edit(FeatureStore.MODE_APPEND);

		FeatureSet set = store.getFeatureSet();

		DisposableIterator iter = set.iterator();

		Feature org;

		EditableFeature trg;

		Iterator attrIter;

		FeatureAttributeDescriptor attr;

		while (iter.hasNext()) {

			org = (Feature) iter.next();

			trg = newstore.createNewFeature(false);

			attrIter = trg.getType().iterator();

			while (attrIter.hasNext()) {

				attr = (FeatureAttributeDescriptor) attrIter.next();

				trg.set(attr.getName(), org.get(attr.getName()));

			}

			newstore.insert(trg);

		}

		newstore.finishEditing();

		iter.dispose();

		set.dispose();

		store.dispose();

		newstore.dispose();

	}

	*/

	@Override

	public NewFeatureStoreParameters getDefaultNewDataStoreParameters()

			throws Exception {

		JDBCStoreParameters params = (JDBCStoreParameters) getDefaultDataStoreParameters();

		if (this.myExplorer == null) {

			MySQLServerExplorerParameters seParameters = null;

			seParameters = (MySQLServerExplorerParameters) dataManager

					.createServerExplorerParameters(MySQLServerExplorer.NAME);

			seParameters.setHost("localhost");

			seParameters.setPort(3306);

			seParameters.setUser("test");

			seParameters.setPassword("test");

			seParameters.setDBName("gis");

			myExplorer = (MySQLServerExplorer) dataManager

					.createServerExplorer(seParameters);

		}

		if (this.newParams == null) {

			FeatureStore store = (FeatureStore) dataManager.createStore(params);

			newParams = (MySQLNewStoreParameters) myExplorer

					.getAddParameters();

			newParams.setTable(params.getTable() + "_test");

			FeatureType ftOrg = store.getDefaultFeatureType();

			EditableFeatureType ftTrg = ftOrg.getEditable();

//			EditableFeatureType ftTrg = (EditableFeatureType) newParams

//					.getDefaultFeatureType();

			newParams.setDefaultFeatureType(ftTrg);

//			FeatureAttributeDescriptor org;

//			EditableFeatureAttributeDescriptor trg;

//			Iterator iter = ftOrg.iterator();

//			while (iter.hasNext()) {

//				org = (FeatureAttributeDescriptor) iter.next();

//				trg = ftTrg.add(org.getName(), org.getDataType());

//				trg.setAllowNull(org.allowNull());

//				trg.setDefaultValue(org.getDefaultValue());

//				trg.setGeometrySubType(org.getGeometrySubType());

//				trg.setGeometryType(org.getGeometryType());

//				trg.setIsAutomatic(org.isAutomatic());

//				trg.setIsPrimaryKey(org.isPrimaryKey());

//				trg.setIsReadOnly(org.isReadOnly());

//				trg.setMaximumOccurrences(org.getMaximumOccurrences());

//				trg.setMinimumOccurrences(org.getMinimumOccurrences());

//				trg.setPrecision(org.getPrecision());

//				trg.setSize(org.getSize());

//				trg.setSRS(org.getSRS());

//				trg.setAdditionalInfo("SQLType", org

//						.getAdditionalInfo("SQLType"));

//				trg.setAdditionalInfo("SQLTypeName", org

//						.getAdditionalInfo("SQLTypeName"));

//

//			}

//			ftTrg.setDefaultGeometryAttributeName(ftOrg

//					.getDefaultGeometryAttributeName());

//			ftTrg.setHasOID(ftOrg.hasOID());

			store.dispose();

		}

		return this.newParams;

	}

	@Override

	public boolean resourcesNotifyChanges() {

		// TODO Auto-generated method stub

		return false;

	}

}

		return this.helper.allowAutomaticValues();

	private Boolean allowAutomaticValues;

		case DataTypes.GEOMETRY:

			if (attr.isAutomatic() && allowAutomaticValues()) {

	public boolean allowAutomaticValues() {

		if (allowAutomaticValues == null) {

			ConnectionAction action = new ConnectionAction(){

				public Object action(Connection conn) throws DataException {

					ResultSet rs;

					try {

						DatabaseMetaData meta = conn.getMetaData();

						rs = meta.getTypeInfo();

						try{

							while (rs.next()) {

								if (rs.getInt("DATA_TYPE") == java.sql.Types.INTEGER) {

									if (rs.getBoolean("AUTO_INCREMENT")) {

										return Boolean.TRUE;

									} else {

										return Boolean.FALSE;

									}

								}

							}

						}finally{

							try{ rs.close();} catch (SQLException ex) {logger.error("Exception closing resulset", ex);};

						}

					} catch (SQLException e) {

						throw new JDBCSQLException(e);

					}

					return Boolean.FALSE;

				}

			};

			try {

				allowAutomaticValues = (Boolean) doConnectionAction(action);

			} catch (Exception e) {

				logger.error("Exception checking for automatic integers", e);

				allowAutomaticValues = Boolean.FALSE;

			}

		}

		return allowAutomaticValues.booleanValue();

	}

	public boolean allowAutomaticValues() {

		return Boolean.TRUE;

	}

/* 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.

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

/**

 *

 */

package org.gvsig.fmap.dal.store.mysql;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.exception.UnsupportedDataTypeException;

import org.gvsig.fmap.dal.resource.spi.ResourceManagerProviderServices;

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.operation.fromwkb.FromWKB;

import org.gvsig.fmap.geom.operation.fromwkb.FromWKBGeometryOperationContext;

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

import org.gvsig.tools.exception.BaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author jmvivo

 *

 */

public class MySQLHelper extends JDBCHelper {

	private static Logger logger = LoggerFactory

			.getLogger(MySQLHelper.class);

	MySQLHelper(JDBCHelperUser consumer,

			MySQLConnectionParameters params)

			throws InitializeException {

		super(consumer, params);

	}

	protected void initializeResource() throws InitializeException {

		ResourceManagerProviderServices manager = (ResourceManagerProviderServices) DALLocator

		.getResourceManager();

		MySQLResource resource = (MySQLResource) manager

		.createResource(

				MySQLResource.NAME, new Object[] {

						params.getUrl(), params.getHost(),

						params.getPort(), params.getDBName(), params.getUser(),

						params.getPassword(),

						params.getJDBCDriverClassName(),

						((MySQLConnectionParameters) params).getUseSSL() });

		this.setResource(resource);

	}

	protected String getDefaultSchema(Connection conn)

			throws JDBCException {

		if (defaultSchema == null) {

			defaultSchema = params.getDBName();

		}

		return defaultSchema;

	}

	public Envelope getFullEnvelopeOfField(

			JDBCStoreParameters storeParams,

			String geometryAttrName, Envelope limit)

			throws DataException {

		StringBuilder strb = new StringBuilder();

		strb.append("Select asbinary(envelope(");

		strb.append(geometryAttrName);

		strb.append(")) from ");

		if (storeParams.getSQL() != null

				&& storeParams.getSQL().trim().length() == 0) {

			strb.append('(');

			strb.append(storeParams.getSQL());

			strb.append(") as __tmp__ ");

		} else {

			strb.append(storeParams.tableID());

		}

		if (limit != null){

			strb.append(" where  intersects(GeomFromText('");

			strb.append(limit.toString());

			strb.append("')), boundary(");

			strb.append(geometryAttrName);

			strb.append(")) ");

		}

		String sql = strb.toString();

		ResultSet rs = null;

		Statement st = null;

		String schema = null;

		Connection conn = null;

		GeometryManager geoMan = GeometryLocator.getGeometryManager();

		Envelope fullEnvelope = null;

		this.open();

		this.begin();

		try{

			conn = getConnection();

			st = conn.createStatement();

			try {

				rs = st.executeQuery(sql);

			} catch (java.sql.SQLException e) {

				throw new JDBCExecuteSQLException(sql, e);

			}

			if (!rs.next()) {

				return null;

			}

			byte[] data = rs.getBytes(1);

			if (data == null) {

				return null;

			}

			initializeFromWKBOperation();

			fromWKBContext.setData(data);

			Geometry geom = (Geometry) fromWKB.invoke(null, fromWKBContext);

			fullEnvelope = geom.getEnvelope();

			return fullEnvelope;

		} catch (java.sql.SQLException e) {

			throw new JDBCSQLException(e);

		} catch (BaseException e) {

			throw new ReadException(user.getName(), e);

		} finally {

			try{ rs.close(); } catch (Exception e){};

			try{ st.close(); } catch (Exception e){};

			try{ conn.close(); } catch (Exception e){};

			rs = null;

			st = null;

			conn = null;

			end();

		}

	}

	protected void initializeFromWKBOperation() throws BaseException {

		if (fromWKB == null) {

			fromWKB = (FromWKB) GeometryLocator.getGeometryManager()

					.getGeometryOperation(FromWKB.CODE,

							Geometry.TYPES.GEOMETRY, Geometry.SUBTYPES.GEOM2D);

			fromWKBContext = new FromWKBGeometryOperationContext();

		}

	}

	public Geometry getGeometry(byte[] buffer) throws BaseException {

		if (buffer == null) {

			return null;

		}

		initializeFromWKBOperation();

		Geometry geom;

		try {

			fromWKBContext.setData(buffer);

			geom = (Geometry) fromWKB.invoke(null, fromWKBContext);

		} finally {

			fromWKBContext.setData(null);

		}

		return geom;

	}

	public String getSqlColumnTypeDescription(FeatureAttributeDescriptor attr) {

		switch (attr.getDataType()) {

		case DataTypes.STRING:

			return "VARCHAR(" + attr.getSize() + ")";

		case DataTypes.BOOLEAN:

			return "BOOL";

		case DataTypes.BYTE:

			return "TINYINT UNSIGNED";

		case DataTypes.DATE:

			return "DATE";

		case DataTypes.TIMESTAMP:

			return "TIMESTAMP";

		case DataTypes.TIME:

			return "TIME";

		case DataTypes.BYTEARRAY:

			if (attr.getSize() > 0) {

				return "BLOB(" + attr.getSize() + ")";

			} else {

				return "BLOB";

			}

		case DataTypes.DOUBLE:

			if (attr.getSize() > 0) {

				return "DOUBLE(" + attr.getSize() + "," + attr.getPrecision()

						+ ")";

			} else {

				return "DOBLE";

			}

		case DataTypes.FLOAT:

			return "FLOAT";

		case DataTypes.GEOMETRY:

			switch (attr.getGeometryType()) {

			case Geometry.TYPES.POINT:

				return "POINT";

			case Geometry.TYPES.CURVE:

				return "LINESTRING";

			case Geometry.TYPES.SURFACE:

				return "SURFACE";

			case Geometry.TYPES.SOLID:

				return "POLYGON";

			case Geometry.TYPES.MULTIPOINT:

				return "MULTIPOIN";

			case Geometry.TYPES.MULTICURVE:

				return "MULTILINESTRING";

			case Geometry.TYPES.MULTISURFACE:

				return "MULTISURFACE";

			case Geometry.TYPES.MULTISOLID:

				return "MULTIPOLYGON";

			default:

				return "GEOMETRY";

			}

		case DataTypes.INT:

			if (attr.getSize() > 0) {

				return "INT(" + attr.getSize() + ")";

			}

		case DataTypes.LONG:

			return "BIGINT";

		default:

			String typeName = (String) attr.getAdditionalInfo("SQLTypeName");

			if (typeName != null) {

				return typeName;

			}

			throw new UnsupportedDataTypeException(attr.getDataTypeName(), attr

					.getDataType());

		}

	}

	public String getSqlFieldName(FeatureAttributeDescriptor attribute) {

		if (attribute.getDataType() == DataTypes.GEOMETRY) {

			return "asBinary(" + super.getSqlFieldName(attribute) + ")";

		}

		return super.getSqlFieldName(attribute);

	}

	protected EditableFeatureAttributeDescriptor createAttributeFromJDBC(

			EditableFeatureType type, Connection conn,

			ResultSetMetaData rsMetadata, int colIndex) throws SQLException {

		int colType = rsMetadata.getColumnType(colIndex);

		if (colType == java.sql.Types.OTHER || colType == java.sql.Types.STRUCT

				|| colType == java.sql.Types.BLOB

				|| colType == java.sql.Types.BINARY) {

			Integer geoType = null;

			if (rsMetadata.getColumnTypeName(colIndex).equalsIgnoreCase(

					"geometry")) {

				geoType = new Integer(Geometry.TYPES.GEOMETRY);

			} else if (rsMetadata.getColumnTypeName(colIndex).equalsIgnoreCase("POINT")) {

				geoType = new Integer(Geometry.TYPES.POINT);

			} else if (rsMetadata.getColumnTypeName(colIndex).equalsIgnoreCase("LINESTRING")) {

				geoType = new Integer(Geometry.TYPES.CURVE);

			} else if (rsMetadata.getColumnTypeName(colIndex).equalsIgnoreCase("SURFACE")) {

				geoType = new Integer(Geometry.TYPES.SURFACE);

			} else if (rsMetadata.getColumnTypeName(colIndex).equalsIgnoreCase("POLYGON")) {

				geoType = new Integer(Geometry.TYPES.SOLID);

			} else if (rsMetadata.getColumnTypeName(colIndex).equalsIgnoreCase("MULTIPOIN")) {

				geoType = new Integer(Geometry.TYPES.MULTIPOINT);

			} else if (rsMetadata.getColumnTypeName(colIndex).equalsIgnoreCase("MULTILINESTRING")) {

				geoType = new Integer(Geometry.TYPES.MULTICURVE);

			} else if (rsMetadata.getColumnTypeName(colIndex).equalsIgnoreCase(

					"MULTISURFACE")) {

				geoType = new Integer(Geometry.TYPES.MULTISURFACE);

			} else if (rsMetadata.getColumnTypeName(colIndex).equalsIgnoreCase(

					"MULTIPOLYGON")) {

				geoType = new Integer(Geometry.TYPES.MULTISOLID);

			}

			if (geoType != null){

				EditableFeatureAttributeDescriptor attr = type.add(rsMetadata

						.getColumnName(colIndex), DataTypes.GEOMETRY);

				attr.setGeometrySubType(Geometry.SUBTYPES.GEOM2D);

				return attr;

			}

		}

		return super.createAttributeFromJDBC(type, conn, rsMetadata, colIndex);

	}

	public String escapeFieldName(String field) {

		if (field.matches("[a-z][a-z0-9_]*")) {

			return field;

		}

		return "`" + field + "`";

	}

	public boolean allowAutomaticValues() {

		return Boolean.TRUE;

	}

	public String getSqlFieldDescription(FeatureAttributeDescriptor attr)

			throws DataException {

		/**

			column_definition:

			    data_type [NOT NULL | NULL] [DEFAULT default_value]

			      [AUTO_INCREMENT] [UNIQUE [KEY] | [PRIMARY] KEY]

			      [COMMENT 'string'] [reference_definition]

		 */

		StringBuilder strb = new StringBuilder();

		// name

		strb.append(escapeFieldName(attr.getName()));

		strb.append(" ");

		// Type

		strb.append(this.getSqlColumnTypeDescription(attr));

		strb.append(" ");

		boolean allowNull = attr.allowNull()

				&& !(attr.isPrimaryKey() || attr.isAutomatic());

		// Null

		if (allowNull) {

			strb.append("NULL ");

		} else {

			strb.append("NOT NULL ");

		}

		if (attr.isAutomatic()) {

			strb.append("AUTO_INCREMENT ");

		}

		// Default

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

			if (allowNull) {

				strb.append("DEFAULT NULL ");

			}

		} else {

			String value = getDefaltFieldValueString(attr);

			strb.append("DEFAULT '");

			strb.append(value);

			strb.append("' ");

		}

		// Primery key

		if (attr.isPrimaryKey()) {

			strb.append("PRIMARY KEY ");

		}

		return strb.toString();

	}

}

/* 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.

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

package org.gvsig.fmap.dal.store.mysql;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObjectManager;

public class MySQLStoreParameters extends JDBCStoreParameters implements

		MySQLConnectionParameters {

    public static final String DYNCLASS_NAME = "MySQLStoreParameters";

    protected static void registerDynClass() {

		DynObjectManager dynman = ToolsLocator.getDynObjectManager();

		DynClass dynClass = dynman.get(DYNCLASS_NAME);

		DynField field;

		if (dynClass == null) {

			dynClass = dynman.add(DYNCLASS_NAME);

			dynClass.extend(JDBCStoreParameters.DYNCLASS_NAME);

			dynClass.extend(MySQLResourceParameters.DYNCLASS_NAME);

		}

	}

	public MySQLStoreParameters() {

		super();

		initialize();

	}

	protected void initialize() {

		DynObjectManager dynman = ToolsLocator.getDynObjectManager();

		DynClass dynClass = dynman.get(DYNCLASS_NAME);

		this.delegatedDynObject = (DelegatedDynObject) dynman

				.createDynObject(dynClass);

	}

	public String getDataStoreName() {

		return MySQLStoreProvider.NAME;

	}

	public String getDescription() {

		return MySQLStoreProvider.DESCRIPTION;

	}

	public Boolean getUseSSL() {

		return (Boolean) this.getDynValue(DYNFIELDNAME_USESSL);

	}

	public void setUseSSL(Boolean useSSL) {

		this.setDynValue(DYNFIELDNAME_USESSL, useSSL);

	}

	public void setUseSSL(boolean useSSL) {

		this.setDynValue(DYNFIELDNAME_USESSL, new Boolean(useSSL));

	}

	public void validate() throws ValidateDataParametersException {

		if (getJDBCDriverClassName() == null) {

			setJDBCDriverClassName(MySQLLibrary.DEFAULT_JDCB_DRIVER_NAME);

		}

		if (getUrl() == null) {

			setUrl(MySQLLibrary.getJdbcUrl(getHost(), getPort(),

					getDBName()));

		}

		if (getPort() == null) {

			setPort(new Integer(3306));

		}

		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.

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

/**

 *

 */

package org.gvsig.fmap.dal.store.mysql;

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

/**

 * @author jmvivo

 *

 */

public interface MySQLConnectionParameters extends

		JDBCConnectionParameters {

	public static final String DYNFIELDNAME_USESSL = "usessl";

	public Boolean getUseSSL();

}

/* 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.

 *

 */

/*

* AUTHORS (In addition to CIT):

* 2008 IVER T.I. S.A.   {{Task}}

*/

package org.gvsig.fmap.dal.store.mysql;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.resource.spi.ResourceManagerProviderServices;

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

import org.gvsig.tools.locator.BaseLibrary;

import org.gvsig.tools.locator.ReferenceNotRegisteredException;

public class MySQLLibrary extends BaseLibrary {

	static String DEFAULT_JDCB_DRIVER_NAME = "com.mysql.jdbc.Driver";

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

		String url;

		String sport = "";

		if (port != null) {

			sport = ":" + port;

		}

		url = "jdbc:mysql://" + host + sport + "/" + db;

		return url;

	}

	public void initialize() throws ReferenceNotRegisteredException {

		super.initialize();

	}

	public void postInitialize() throws ReferenceNotRegisteredException {

		super.postInitialize();

    	ResourceManagerProviderServices resman = (ResourceManagerProviderServices) DALLocator

				.getResourceManager();

    	MySQLResourceParameters.registerDynClass();

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

			resman.register(MySQLResource.NAME,

					MySQLResource.DESCRIPTION, MySQLResource.class,

					MySQLResourceParameters.class);

		}

    	MySQLStoreParameters.registerDynClass();

    	MySQLNewStoreParameters.registerDynClass();

		MySQLStoreProvider.registerDynClass();

        DataManagerProviderServices dataman = (DataManagerProviderServices) DALLocator

				.getDataManager();

		if (!dataman.getStoreProviders().contains(MySQLStoreProvider.NAME)) {

			dataman.registerStoreProvider(MySQLStoreProvider.NAME,

					MySQLStoreProvider.class,

					MySQLStoreParameters.class);

		}

		if (!dataman.getExplorerProviders().contains(

				MySQLStoreProvider.NAME)) {

			dataman.registerExplorerProvider(MySQLServerExplorer.NAME,

					MySQLServerExplorer.class,

					MySQLServerExplorerParameters.class);

		}

	}

}

/* 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.

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

/**

 *

 */

package org.gvsig.fmap.dal.store.mysql;

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

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

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

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

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

/**

 * @author jmvivo

 *

 */

public class MySQLSetProvider extends JDBCSetProvider {

	public MySQLSetProvider(JDBCStoreProvider store, FeatureQuery query,

			FeatureType featureType) throws DataException {

		super(store, query, featureType);

		// TODO Auto-generated constructor stub

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see org.gvsig.fmap.dal.feature.spi.FeatureSetProvider#canFilter()

	 */

	public boolean canFilter() {

		// TODO more checks

		if (!super.canFilter()) {

			return false;

		}

		return true;

	}

}

/* 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.

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

package org.gvsig.fmap.dal.store.mysql;

import java.text.MessageFormat;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSource;

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

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

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

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

public class MySQLResource extends JDBCResource {

	public final static String NAME = "MySQLResource";

	public static final String DESCRIPTION = "MySQL Connection";

	public MySQLResource(MySQLResourceParameters parameters)

			throws InitializeException {

		super(parameters);

	}

	public String getName() throws AccessResourceException {

		MySQLResourceParameters params = (MySQLResourceParameters) this.getParameters();

		return MessageFormat.format("MySQLResource({0},{1})",

				new Object[] { params.getUrl(),params.getUser() });

	}

	protected void connectToDB() throws DataException {

		super.connectToDB();

	}

	protected DataSource createDataSource() {

		MySQLResourceParameters jdbcParams = (MySQLResourceParameters) this

				.getParameters();

		BasicDataSource dataSource = new BasicDataSource();

		dataSource.setDriverClassName(jdbcParams.getJDBCDriverClassName());

		dataSource.setUsername(jdbcParams.getUser());

		dataSource.setPassword(jdbcParams.getPassword());

		dataSource.setUrl(jdbcParams.getUrl());

		dataSource.setMaxWait(60L * 1000); // FIXME

		// FIXME Set Pool parameters:

		/*

		dataSource.setMaxActive(maxActive);

		dataSource.setMaxIdle(maxActive);

		dataSource.setMaxOpenPreparedStatements(maxActive);

		dataSource.setMaxWait(maxActive);

		dataSource.setInitialSize(initialSize);

		dataSource.setDefaultReadOnly(defaultReadOnly);

		dataSource.setDefaultTransactionIsolation(defaultTransactionIsolation);

		dataSource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);

		dataSource.setMinIdle(minIdle);

		dataSource.setTestOnBorrow(testOnBorrow);

		dataSource.setTestOnReturn(testOnReturn);

		dataSource.setTestWhileIdle(testOnReturn);

		dataSource

			.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);

		dataSource.setAccessToUnderlyingConnectionAllowed(allow);

		dataSource.setLoginTimeout(seconds);

		dataSource.setLogWriter(out);

		 */

		return dataSource;

	}

}

/* 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.

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

/**

 *

 */

package org.gvsig.fmap.dal.store.mysql;

import java.sql.Connection;

import java.sql.SQLException;

import java.sql.Statement;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.NewDataStoreParameters;

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

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

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

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

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

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

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

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

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author jmvivo

 *

 */

public class MySQLServerExplorer extends JDBCServerExplorer {

	final static private Logger logger = LoggerFactory

			.getLogger(MySQLServerExplorer.class);

	public static final String NAME = "MySQLExplorer";

	private MySQLServerExplorerParameters myParameters;

	public MySQLServerExplorer(

			MySQLServerExplorerParameters parameters)

			throws InitializeException {

		super(parameters);

	}

	protected void init(JDBCServerExplorerParameters parameters)

			throws InitializeException {

		myParameters = (MySQLServerExplorerParameters) parameters;

		super.init(parameters);

	}

	protected JDBCHelper createHelper() throws InitializeException {

		return new MySQLHelper(this, myParameters);

	}

	protected String getStoreName() {

		return MySQLStoreProvider.NAME;

	}

	public String getName() {

		return NAME;

	}

	protected JDBCStoreParameters createStoreParams()

			throws InitializeException, ProviderNotRegisteredException {

		MySQLStoreParameters orgParams = (MySQLStoreParameters) super

				.createStoreParams();

		orgParams.setUseSSL(myParameters.getUseSSL());

		return orgParams;

	}

	// ****************************

	public boolean canAdd() {

		return true;

	}

	protected void checkIsMine(DataStoreParameters dsp) {

		if (!(dsp instanceof MySQLStoreParameters)) {

			// FIXME Excpetion ???

			throw new IllegalArgumentException(

					"not instance of MySQLStoreParameters");

		}

		super.checkIsMine(dsp);

		MySQLStoreParameters myp = (MySQLStoreParameters) dsp;

		if (myp.getUseSSL().booleanValue() != myParameters.getUseSSL()) {

			throw new IllegalArgumentException("worng explorer: useSSL (mine:"

					+ myParameters.getUseSSL() + " other:" + myp.getUseSSL()

					+ ")");

		}

	}

	public void remove(DataStoreParameters dsp) throws RemoveException {

		final MySQLStoreParameters myParams =(MySQLStoreParameters) dsp;

		TransactionalAction action = new TransactionalAction() {

			public boolean continueTransactionAllowed() {

				return false;

			}

			public Object action(Connection conn) throws DataException {

				Statement st;

				try{

					st = conn.createStatement();

				} catch (SQLException e) {

					throw new JDBCSQLException(e);

				}

				String sqlDrop = "Drop table "

					+ myParams.tableID();

				try{

					try{

						st.execute(sqlDrop);

					} catch (SQLException e) {

						throw new JDBCExecuteSQLException(sqlDrop, e);

					}

				} finally{

					try{ st.close(); } catch (SQLException e) {};

				}

				return null;

			}

		};

		try {

			this.helper.doConnectionAction(action);

		} catch (Exception e) {

			throw new RemoveException(this.getName(), e);

		}

	}

	public NewDataStoreParameters getAddParameters() throws DataException {

		MySQLNewStoreParameters params = new MySQLNewStoreParameters();

		params.setHost(this.parameters.getHost());

		params.setPort(this.parameters.getPort());

		params.setDBName(this.parameters.getDBName());

		params.setUser(this.parameters.getUser());

		params.setPassword(this.parameters.getPassword());

		params.setCatalog(this.parameters.getCatalog());

		params.setSchema(this.parameters.getSchema());

		params.setJDBCDriverClassName(this.parameters.getJDBCDriverClassName());

		params.setUrl(this.parameters.getUrl());

		params.setUseSSL(((MySQLServerExplorerParameters) this.parameters)

				.getUseSSL());

		params.setDefaultFeatureType(this.getServerExplorerProviderServices()

				.createNewFeatureType());