diff --git "a/Java/AbstractEpsgFactory.java" "b/Java/AbstractEpsgFactory.java" new file mode 100644--- /dev/null +++ "b/Java/AbstractEpsgFactory.java" @@ -0,0 +1,3668 @@ +/* + * GeoTools - The Open Source Java GIS Toolkit + * http://geotools.org + * + * (C) 2005-2008, Open Source Geospatial Foundation (OSGeo) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; + * version 2.1 of the License. + * + * This library 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 + * Lesser General Public License for more details. + */ +package org.geotools.referencing.factory.epsg; + +import static org.geotools.measure.Units.DEGREE_ANGLE; +import static org.geotools.measure.Units.DEGREE_MINUTE_SECOND; +import static org.geotools.measure.Units.FOOT; +import static org.geotools.measure.Units.GRADE; +import static org.geotools.measure.Units.KILOMETER; +import static org.geotools.measure.Units.METRE; +import static org.geotools.measure.Units.MICRORADIAN; +import static org.geotools.measure.Units.MINUTE_ANGLE; +import static org.geotools.measure.Units.NAUTICAL_MILE; +import static org.geotools.measure.Units.ONE; +import static org.geotools.measure.Units.PPM; +import static org.geotools.measure.Units.RADIAN; +import static org.geotools.measure.Units.SECOND_ANGLE; +import static org.geotools.measure.Units.SEXAGESIMAL_DMS; + +import java.awt.RenderingHints; +import java.io.File; +import java.io.IOException; +import java.io.ObjectStreamException; +import java.io.Serializable; +import java.net.URI; +import java.net.URISyntaxException; +import java.sql.Connection; +import java.sql.DatabaseMetaData; +import java.sql.Date; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.ResultSetMetaData; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.AbstractMap; +import java.util.AbstractSet; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.IdentityHashMap; +import java.util.Iterator; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Set; +import java.util.logging.Level; +import java.util.logging.LogRecord; +import javax.measure.Unit; +import javax.measure.quantity.Angle; +import javax.measure.quantity.Length; +import javax.naming.NamingException; +import javax.sql.DataSource; +import org.geotools.measure.Units; +import org.geotools.metadata.i18n.ErrorKeys; +import org.geotools.metadata.i18n.Errors; +import org.geotools.metadata.i18n.LoggingKeys; +import org.geotools.metadata.i18n.Loggings; +import org.geotools.metadata.i18n.Vocabulary; +import org.geotools.metadata.i18n.VocabularyKeys; +import org.geotools.metadata.iso.citation.CitationImpl; +import org.geotools.metadata.iso.citation.Citations; +import org.geotools.metadata.iso.extent.ExtentImpl; +import org.geotools.metadata.iso.extent.GeographicBoundingBoxImpl; +import org.geotools.metadata.iso.quality.AbsoluteExternalPositionalAccuracyImpl; +import org.geotools.metadata.iso.quality.QuantitativeResultImpl; +import org.geotools.parameter.DefaultParameterDescriptor; +import org.geotools.parameter.DefaultParameterDescriptorGroup; +import org.geotools.referencing.AbstractIdentifiedObject; +import org.geotools.referencing.NamedIdentifier; +import org.geotools.referencing.cs.DefaultCoordinateSystemAxis; +import org.geotools.referencing.datum.BursaWolfParameters; +import org.geotools.referencing.datum.DefaultGeodeticDatum; +import org.geotools.referencing.factory.AbstractCachedAuthorityFactory; +import org.geotools.referencing.factory.BufferedAuthorityFactory; +import org.geotools.referencing.factory.DirectAuthorityFactory; +import org.geotools.referencing.factory.IdentifiedObjectFinder; +import org.geotools.referencing.operation.DefaultConcatenatedOperation; +import org.geotools.referencing.operation.DefaultOperation; +import org.geotools.referencing.operation.DefaultOperationMethod; +import org.geotools.referencing.operation.DefiningConversion; +import org.geotools.referencing.util.CRSUtilities; +import org.geotools.util.LocalName; +import org.geotools.util.ObjectCache; +import org.geotools.util.ScopedName; +import org.geotools.util.SimpleInternationalString; +import org.geotools.util.TableWriter; +import org.geotools.util.Version; +import org.geotools.util.factory.GeoTools; +import org.geotools.util.factory.Hints; +import org.geotools.util.logging.Logging; +import org.opengis.metadata.Identifier; +import org.opengis.metadata.citation.Citation; +import org.opengis.metadata.extent.Extent; +import org.opengis.metadata.quality.EvaluationMethodType; +import org.opengis.metadata.quality.PositionalAccuracy; +import org.opengis.parameter.InvalidParameterValueException; +import org.opengis.parameter.ParameterDescriptor; +import org.opengis.parameter.ParameterNotFoundException; +import org.opengis.parameter.ParameterValue; +import org.opengis.parameter.ParameterValueGroup; +import org.opengis.referencing.FactoryException; +import org.opengis.referencing.IdentifiedObject; +import org.opengis.referencing.NoSuchAuthorityCodeException; +import org.opengis.referencing.NoSuchIdentifierException; +import org.opengis.referencing.crs.CRSFactory; +import org.opengis.referencing.crs.CompoundCRS; +import org.opengis.referencing.crs.CoordinateReferenceSystem; +import org.opengis.referencing.crs.GeneralDerivedCRS; +import org.opengis.referencing.crs.GeocentricCRS; +import org.opengis.referencing.crs.GeographicCRS; +import org.opengis.referencing.crs.ProjectedCRS; +import org.opengis.referencing.crs.SingleCRS; +import org.opengis.referencing.cs.AxisDirection; +import org.opengis.referencing.cs.CSFactory; +import org.opengis.referencing.cs.CartesianCS; +import org.opengis.referencing.cs.CoordinateSystem; +import org.opengis.referencing.cs.CoordinateSystemAxis; +import org.opengis.referencing.cs.EllipsoidalCS; +import org.opengis.referencing.cs.SphericalCS; +import org.opengis.referencing.cs.VerticalCS; +import org.opengis.referencing.datum.Datum; +import org.opengis.referencing.datum.DatumFactory; +import org.opengis.referencing.datum.Ellipsoid; +import org.opengis.referencing.datum.EngineeringDatum; +import org.opengis.referencing.datum.GeodeticDatum; +import org.opengis.referencing.datum.PrimeMeridian; +import org.opengis.referencing.datum.VerticalDatum; +import org.opengis.referencing.datum.VerticalDatumType; +import org.opengis.referencing.operation.ConcatenatedOperation; +import org.opengis.referencing.operation.Conversion; +import org.opengis.referencing.operation.CoordinateOperation; +import org.opengis.referencing.operation.MathTransform; +import org.opengis.referencing.operation.OperationMethod; +import org.opengis.referencing.operation.Projection; +import org.opengis.referencing.operation.Transformation; +import org.opengis.util.GenericName; +import org.opengis.util.InternationalString; +import si.uom.NonSI; +import si.uom.SI; + +/** + * A coordinate reference system factory backed by the EPSG database tables. + * + *

The EPSG database is freely available at http://www.epsg.org. Current version of this class requires EPSG + * database version 6.6 or above. + * + *

This factory makes use of a provided {@link ObjectCache}, and may be deployed in stand aline + * fashion; or as a worker for a {@link MultiEpsgFactory}. + * + *

This class is abstract - please see the subclasses for dialect specific implementations: + * + *

+ * + * These factories accepts names as well as numerical identifiers. For example "NTF (Paris) / + * France I" and {@code "27581"} both fetchs the same object. However, names may be ambiguous + * since the same name may be used for more than one object. This is the case of "WGS 84" for + * example. If such an ambiguity is found, an exception will be thrown. If names are not wanted as a + * legal EPSG code, subclasses can override the {@link #isPrimaryKey} method. + * + * @since 2.4 + * @version $Id$ + * @author Yann Cézard + * @author Martin Desruisseaux (IRD) + * @author Rueben Schulz + * @author Matthias Basler + * @author Andrea Aime + */ +@SuppressWarnings("PMD.CloseResource") // class implements its own PreparedStatement pooling +public abstract class AbstractEpsgFactory extends AbstractCachedAuthorityFactory { + /// Datum shift operation methods + /** First Bursa-Wolf method. */ + private static final int BURSA_WOLF_MIN_CODE = 9603; + + /** Last Bursa-Wolf method. */ + private static final int BURSA_WOLF_MAX_CODE = 9607; + + /** Rotation frame method. */ + private static final int ROTATION_FRAME_CODE = 9607; + + /** Dummy operation to ignore. */ + private static final int DUMMY_OPERATION = 1; + + /** The name for the transformation accuracy metadata. */ + private static final InternationalString TRANSFORMATION_ACCURACY = + Vocabulary.formatInternational(VocabularyKeys.TRANSFORMATION_ACCURACY); + + /** + * The authority for this database. Will be created only when first needed. This authority will + * contains the database version in the {@linkplain Citation#getEdition edition} attribute, + * together with the {@linkplain Citation#getEditionDate edition date}. + */ + private transient Citation authority; // FIXME: always EPSG + + /** A DataSource to the EPSG database being used. */ + protected javax.sql.DataSource dataSource; + + /** + * The connection to the EPSG database - this is create in a lazy manner from the DataSource. + * + *

This field is managed as part of our connection lifecycle. + */ + private Connection connection; + + /** + * A pool of prepared statements. Key are {@link String} object related to their originating + * method name (for example "Ellipsoid" for {@link #createEllipsoid}, while values are {@link + * PreparedStatement} objects. + * + *

Note: It is okay to use {@link IdentityHashMap} instead of {@link + * HashMap} because the keys will always be the exact same object, namely the hard-coded + * argument given to calls to {@link #prepareStatement} in this class. + * + *

This field is managed as part of our connection lifecycle. + */ + private final Map statements = new IdentityHashMap<>(); + + /** + * Last object type returned by {@link #createObject}, or -1 if none. This type is an index in + * the {@link #TABLES_INFO} array and is strictly for {@link #createObject} internal use. + */ + private int lastObjectType = -1; + + /** + * The last table in which object name were looked for. This is for internal use by {@link + * #toPrimaryKey} only. + */ + private transient String lastTableForName; + + /** + * Cache for axis names. This service is not provided by {@link BufferedAuthorityFactory} since + * {@link AxisName} object are particular to the EPSG database. + * + * @see #getAxisName + */ + private final Map axisNames = new HashMap<>(); + + /** + * Cache for axis numbers. This service is not provided by {@link BufferedAuthorityFactory} + * since the number of axis is used internally in this class. + * + * @see #getDimensionForCRS + */ + private final Map axisCounts = new HashMap<>(); + + /** + * Cache for projection checks. This service is not provided by {@link BufferedAuthorityFactory} + * since the check that a transformation is a projection is used internally in this class. + * + * @see #isProjection + */ + private final Map codeProjection = new HashMap<>(); + + /** Pool of naming systems, used for caching. There is usually few of them (about 15). */ + private final Map scopes = new HashMap<>(); + + /** + * The properties to be given the objects to construct. Reused every time {@link + * #createProperties} is invoked. + */ + private final Map properties = new HashMap<>(); + + /** + * A safety guard for preventing never-ending loops in recursive calls to {@link #createDatum}. + * This is used by {@link #createBursaWolfParameters}, which need to create a target datum. The + * target datum could have its own Bursa-Wolf parameters, with one of them pointing again to the + * source datum. + */ + private final Set safetyGuard = new HashSet<>(); + + public AbstractEpsgFactory(final Hints userHints) throws FactoryException { + super(MAXIMUM_PRIORITY - 20); + // The following hints have no effect on this class behaviour, + // but tell to the user what this factory do about axis order. + hints.put(Hints.FORCE_LONGITUDE_FIRST_AXIS_ORDER, Boolean.FALSE); + hints.put(Hints.FORCE_STANDARD_AXIS_DIRECTIONS, Boolean.FALSE); + hints.put(Hints.FORCE_STANDARD_AXIS_UNITS, Boolean.FALSE); + + // + // We need to obtain our DataSource + if (userHints != null) { + Object hint = userHints.get(Hints.EPSG_DATA_SOURCE); + if (hint instanceof String) { + String name = (String) hint; + try { + // BUG: CWE-20 Improper Input Validation + // dataSource = (DataSource) GeoTools.getInitialContext().lookup(name); + // FIXED: + dataSource = (DataSource) GeoTools.jndiLookup(name); + } catch (NamingException e) { + throw new FactoryException("A EPSG_DATA_SOURCE hint is required:" + e); + } + hints.put(Hints.EPSG_DATA_SOURCE, dataSource); + } else if (hint instanceof DataSource) { + dataSource = (DataSource) hint; + hints.put(Hints.EPSG_DATA_SOURCE, dataSource); + } else { + throw new FactoryException("A EPSG_DATA_SOURCE hint is required."); + } + } else { + throw new FactoryException("A EPSG_DATA_SOURCE hint is required."); + } + } + + public AbstractEpsgFactory(final Hints userHints, final javax.sql.DataSource dataSource) { + super(MAXIMUM_PRIORITY - 20); + + this.dataSource = dataSource; + // The following hints have no effect on this class behaviour, + // but tell to the user what this factory do about axis order. + hints.put(Hints.FORCE_LONGITUDE_FIRST_AXIS_ORDER, Boolean.FALSE); + hints.put(Hints.FORCE_STANDARD_AXIS_DIRECTIONS, Boolean.FALSE); + hints.put(Hints.FORCE_STANDARD_AXIS_UNITS, Boolean.FALSE); + hints.put(Hints.EPSG_DATA_SOURCE, dataSource); + } + /** + * Constructs an authority factory using the specified connection. + * + * @param userHints The underlying factories used for objects creation. + * @param connection The connection to the underlying EPSG database. + */ + public AbstractEpsgFactory(final Hints userHints, final Connection connection) { + super(MAXIMUM_PRIORITY - 20, userHints); + // The following hints have no effect on this class behaviour, + // but tell to the user what this factory do about axis order. + hints.put(Hints.FORCE_LONGITUDE_FIRST_AXIS_ORDER, Boolean.FALSE); + hints.put(Hints.FORCE_STANDARD_AXIS_DIRECTIONS, Boolean.FALSE); + hints.put(Hints.FORCE_STANDARD_AXIS_UNITS, Boolean.FALSE); + this.connection = connection; + ensureNonNull("connection", connection); + } + + /** + * Returns the authority for this EPSG database. This authority will contains the database + * version in the {@linkplain Citation#getEdition edition} attribute, together with the + * {@linkplain Citation#getEditionDate edition date}. + */ + @Override + public synchronized Citation getAuthority() { + if (authority == null) + try { + final String query = + adaptSQL( + "SELECT VERSION_NUMBER, VERSION_DATE FROM [Version History]" + + " ORDER BY VERSION_DATE DESC"); + final DatabaseMetaData metadata = getConnection().getMetaData(); + try (Statement statement = getConnection().createStatement(); + ResultSet result = statement.executeQuery(query)) { + if (result.next()) { + final String version = result.getString(1); + final Date date = result.getDate(2); + final String engine = metadata.getDatabaseProductName(); + final CitationImpl c = new CitationImpl(Citations.EPSG); + c.getAlternateTitles() + .add( + Vocabulary.formatInternational( + VocabularyKeys.DATA_BASE_$3, + "EPSG", + version, + engine)); + c.setEdition(new SimpleInternationalString(version)); + c.setEditionDate(date); + authority = (Citation) c.unmodifiable(); + hints.put( + Hints.VERSION, + new Version(version)); // For getImplementationHints() + } else { + authority = Citations.EPSG; + } + } + } catch (SQLException exception) { + Logging.unexpectedException( + LOGGER, AbstractEpsgFactory.class, "getAuthority", exception); + return Citations.EPSG; + } + return authority; + } + + /** + * Returns a description of the database engine. + * + * @throws FactoryException if the database's metadata can't be fetched. + */ + @Override + public synchronized String getBackingStoreDescription() throws FactoryException { + final Citation authority = getAuthority(); + try (TableWriter table = new TableWriter(null, " ")) { + final Vocabulary resources = Vocabulary.getResources(null); + CharSequence cs; + if ((cs = authority.getEdition()) != null) { + table.write(resources.getString(VocabularyKeys.VERSION_OF_$1, "EPSG")); + table.write(':'); + table.nextColumn(); + table.write(cs.toString()); + table.nextLine(); + } + try { + String s; + final DatabaseMetaData metadata = getConnection().getMetaData(); + if ((s = metadata.getDatabaseProductName()) != null) { + table.write(resources.getLabel(VocabularyKeys.DATABASE_ENGINE)); + table.nextColumn(); + table.write(s); + if ((s = metadata.getDatabaseProductVersion()) != null) { + table.write(' '); + table.write(resources.getString(VocabularyKeys.VERSION_$1, s)); + } + table.nextLine(); + } + if ((s = metadata.getURL()) != null) { + table.write(resources.getLabel(VocabularyKeys.DATABASE_URL)); + table.nextColumn(); + table.write(s); + table.nextLine(); + } + } catch (SQLException exception) { + throw new FactoryException(exception); + } + return table.toString(); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + /** + * Returns the implementation hints for this factory. The returned map contains all the values + * specified in {@linkplain DirectAuthorityFactory#getImplementationHints subclass}, with the + * addition of {@link Hints#VERSION VERSION}. + */ + @Override + public Map getImplementationHints() { + if (authority == null) { + // For the computation of Hints.VERSION. + getAuthority(); + } + return super.getImplementationHints(); + } + + /** + * Returns the set of authority codes of the given type. + * + * @param type The spatial reference objects type (may be {@code Object.class}). + * @return The set of authority codes for spatial reference objects of the given type. If this + * factory doesn't contains any object of the given type, then this method returns an empty + * set. + * @throws FactoryException if access to the underlying database failed. + */ + @Override + protected synchronized Set generateAuthorityCodes(final Class type) + throws FactoryException { + Set result = new HashSet<>(); + for (final TableInfo table : TABLES_INFO) { + if (table.isTypeOf(type)) { + final AuthorityCodeSet codes = new AuthorityCodeSet(table, type); + result.addAll(codes); + } + } + return result; + } + + /** + * Gets a description of the object corresponding to a code. + * + * @param code Value allocated by authority. + * @return A description of the object, or {@code null} if the object corresponding to the + * specified {@code code} has no description. + * @throws NoSuchAuthorityCodeException if the specified {@code code} was not found. + * @throws FactoryException if the query failed for some other reason. + */ + @Override + public InternationalString getDescriptionText(final String code) throws FactoryException { + IdentifiedObject identifiedObject = createObject(code); + final Identifier identifier = identifiedObject.getName(); + if (identifier instanceof GenericName) { + return ((GenericName) identifier).toInternationalString(); + } + return new SimpleInternationalString(identifier.getCode()); + } + + /** + * Returns a prepared statement for the specified name. Most {@link PreparedStatement} creations + * are performed through this method, except {@link #getNumericalIdentifier} and {@link + * #createObject}. + * + * @param key A key uniquely identifying the caller (e.g. {@code "Ellipsoid"} for {@link + * #createEllipsoid}). + * @param sql The SQL statement to use if for creating the {@link PreparedStatement} object. + * Will be used only if no prepared statement was already created for the specified key. + * @return The prepared statement. + * @throws SQLException if the prepared statement can't be created. + */ + private PreparedStatement prepareStatement(final String key, final String sql) + throws SQLException { + assert Thread.holdsLock(this); + PreparedStatement stmt = statements.get(key); + if (stmt == null) { + stmt = getConnection().prepareStatement(adaptSQL(sql)); + statements.put(key, stmt); + } + return stmt; + } + + /** + * Gets the string from the specified {@link ResultSet}. The string is required to be non-null. + * A null string will throw an exception. + * + * @param result The result set to fetch value from. + * @param columnIndex The column index (1-based). + * @param code The identifier of the record where the string was found. + * @return The string at the specified column. + * @throws SQLException if a SQL error occured. + * @throws FactoryException If a null value was found. + */ + private static String getString( + final ResultSet result, final int columnIndex, final String code) + throws SQLException, FactoryException { + final String value = result.getString(columnIndex); + ensureNonNull(result, columnIndex, code); + return value.trim(); + } + + /** + * Same as {@link #getString(ResultSet,int,String)}, but report the fault on an alternative + * column if the value is null. + */ + private static String getString( + final ResultSet result, final int columnIndex, final String code, final int columnFault) + throws SQLException, FactoryException { + final String str = result.getString(columnIndex); + if (result.wasNull()) { + final ResultSetMetaData metadata = result.getMetaData(); + final String column = metadata.getColumnName(columnFault); + final String table = metadata.getTableName(columnFault); + result.close(); + throw new FactoryException( + Errors.format(ErrorKeys.NULL_VALUE_IN_TABLE_$3, code, column, table)); + } + return str.trim(); + } + + /** + * Gets the value from the specified {@link ResultSet}. The value is required to be non-null. A + * null value (i.e. blank) will throw an exception. + * + * @param result The result set to fetch value from. + * @param columnIndex The column index (1-based). + * @param code The identifier of the record where the string was found. + * @return The double at the specified column. + * @throws SQLException if a SQL error occured. + * @throws FactoryException If a null value was found. + */ + private static double getDouble( + final ResultSet result, final int columnIndex, final String code) + throws SQLException, FactoryException { + final double value = result.getDouble(columnIndex); + ensureNonNull(result, columnIndex, code); + return value; + } + + /** + * Gets the value from the specified {@link ResultSet}. The value is required to be non-null. A + * null value (i.e. blank) will throw an exception. + * + * @param result The result set to fetch value from. + * @param columnIndex The column index (1-based). + * @param code The identifier of the record where the string was found. + * @return The integer at the specified column. + * @throws SQLException if a SQL error occured. + * @throws FactoryException If a null value was found. + */ + private static int getInt(final ResultSet result, final int columnIndex, final String code) + throws SQLException, FactoryException { + final int value = result.getInt(columnIndex); + ensureNonNull(result, columnIndex, code); + return value; + } + + /** + * Make sure that the last result was non-null. Used for {@code getString}, {@code getDouble} + * and {@code getInt} methods only. + */ + private static void ensureNonNull( + final ResultSet result, final int columnIndex, final String code) + throws SQLException, FactoryException { + if (result.wasNull()) { + final ResultSetMetaData metadata = result.getMetaData(); + final String column = metadata.getColumnName(columnIndex); + final String table = metadata.getTableName(columnIndex); + result.close(); + throw new FactoryException( + Errors.format(ErrorKeys.NULL_VALUE_IN_TABLE_$3, code, column, table)); + } + } + + /** + * Converts a code from an arbitrary name to the numerical identifier (the primary key). If the + * supplied code is already a numerical value, then it is returned unchanged. If the code is not + * found in the name column, it is returned unchanged as well so that the caller will produces + * an appropriate "Code not found" error message. If the code is found more than once, then an + * exception is thrown. + * + *

Note that this method includes a call to {@link #trimAuthority}, so there is no need to + * call it before or after this method. + * + * @param type The type of object to create. + * @param code The code to check. + * @param table The table where the code should appears. + * @param codeColumn The column name for the code. + * @param nameColumn The column name for the name. + * @return The numerical identifier (i.e. the table primary key value). + * @throws SQLException if an error occured while reading the database. + */ + private String toPrimaryKey( + final Class type, + final String code, + final String table, + final String codeColumn, + final String nameColumn) + throws SQLException, FactoryException { + assert Thread.holdsLock(this); + String identifier = trimAuthority(code); + if (!isPrimaryKey(identifier)) { + /* + * The character is not the numerical code. Search the value in the database. + * If a prepared statement is already available, reuse it providing that it was + * created for the current table. Otherwise, we will create a new statement. + */ + final String KEY = "NumericalIdentifier"; + PreparedStatement statement = statements.get(KEY); + if (statement != null) { + if (!table.equals(lastTableForName)) { + statements.remove(KEY); + statement.close(); + statement = null; + lastTableForName = null; + } + } + if (statement == null) { + final String query = + "SELECT " + codeColumn + " FROM " + table + " WHERE " + nameColumn + " = ?"; + statement = getConnection().prepareStatement(adaptSQL(query)); + statements.put(KEY, statement); + } + statement.setString(1, identifier); + identifier = null; + try (ResultSet result = statement.executeQuery()) { + while (result.next()) { + identifier = ensureSingleton(result.getString(1), identifier, code); + } + } + if (identifier == null) { + throw noSuchAuthorityCode(type, code); + } + } + return identifier; + } + + /** + * Make sure that an object constructed from the database is not incoherent. If the code + * supplied to a {@code createFoo} method exists in the database, then we should find only one + * record. However, we will do a paranoiac check and verify if there is more records, using a + * {@code while (results.next())} loop instead of {@code if (results.next())}. This method is + * invoked in the loop for making sure that, if there is more than one record (which should + * never happen), at least they have identical contents. + * + * @param newValue The newly constructed object. + * @param oldValue The object previously constructed, or {@code null} if none. + * @param code The EPSG code (for formatting error message). + * @throws FactoryException if a duplication has been detected. + * @todo Use generic type when we will be allowed to compile for J2SE 1.5. + */ + private static T ensureSingleton(final T newValue, final T oldValue, final String code) + throws FactoryException { + if (oldValue == null) { + return newValue; + } + if (oldValue.equals(newValue)) { + return oldValue; + } + throw new FactoryException(Errors.format(ErrorKeys.DUPLICATED_VALUES_$1, code)); + } + + /** + * Returns the name for the {@link IdentifiedObject} to construct. This method also search for + * alias. + * + * @param name The name for the {@link IndentifiedObject} to construct. + * @param code The EPSG code of the object to construct. + * @param remarks Remarks, or {@code null} if none. + * @return The name together with a set of properties. + */ + private Map generateProperties( + final String name, final String code, String remarks) + throws SQLException, FactoryException { + properties.clear(); + final Citation authority = getAuthority(); + if (name != null) { + properties.put(IdentifiedObject.NAME_KEY, new NamedIdentifier(authority, name.trim())); + } + if (code != null) { + final InternationalString edition = authority.getEdition(); + final String version = (edition != null) ? edition.toString() : null; + properties.put( + IdentifiedObject.IDENTIFIERS_KEY, + new NamedIdentifier(authority, code.trim(), version)); + } + if (remarks != null && (remarks = remarks.trim()).length() != 0) { + properties.put(IdentifiedObject.REMARKS_KEY, remarks); + } + /* + * Search for alias. + */ + List alias = null; + final PreparedStatement stmt = + prepareStatement( + "Alias", + "SELECT NAMING_SYSTEM_NAME, ALIAS" + + " FROM [Alias] INNER JOIN [Naming System]" + + " ON [Alias].NAMING_SYSTEM_CODE =" + + " [Naming System].NAMING_SYSTEM_CODE" + + " WHERE OBJECT_CODE = ?"); + stmt.setString(1, code); + try (ResultSet result = stmt.executeQuery()) { + while (result.next()) { + final String scope = result.getString(1); + final String local = getString(result, 2, code); + final GenericName generic; + if (scope == null) { + generic = new LocalName(local); + } else { + LocalName cached = scopes.get(scope); + if (cached == null) { + cached = new LocalName(scope); + scopes.put(scope, cached); + } + generic = new ScopedName(cached, local); + } + if (alias == null) { + alias = new ArrayList<>(); + } + alias.add(generic); + } + } + if (alias != null) { + properties.put( + IdentifiedObject.ALIAS_KEY, alias.toArray(new GenericName[alias.size()])); + } + return properties; + } + + /** + * Returns the name for the {@link IdentifiedObject} to construct. This method also search for + * alias. + * + * @param name The name for the {@link IndentifiedObject} to construct. + * @param code The EPSG code of the object to construct. + * @param area The area of use, or {@code null} if none. + * @param scope The scope, or {@code null} if none. + * @param remarks Remarks, or {@code null} if none. + * @return The name together with a set of properties. + */ + private Map generateProperties( + final String name, final String code, String area, String scope, String remarks) + throws SQLException, FactoryException { + final Map properties = generateProperties(name, code, remarks); + if (area != null && (area = area.trim()).length() != 0) { + final Extent extent = generateExtent(area); + properties.put(Datum.DOMAIN_OF_VALIDITY_KEY, extent); + } + if (scope != null && (scope = scope.trim()).length() != 0) { + properties.put(Datum.SCOPE_KEY, scope); + } + return properties; + } + + /** + * Returns an arbitrary object from a code. The default implementation invokes one of {@link + * #createCoordinateReferenceSystem}, {@link #createCoordinateSystem}, {@link #createDatum}, + * {@link #createEllipsoid}, or {@link #createUnit} methods according the object type. + * + * @param code The EPSG value. + * @return The object. + * @throws NoSuchAuthorityCodeException if this method can't find the requested code. + * @throws FactoryException if some other kind of failure occured in the backing store. This + * exception usually have {@link SQLException} as its cause. + */ + @Override + @SuppressWarnings("PMD.OverrideBothEqualsAndHashcode") + public synchronized IdentifiedObject generateObject(final String code) throws FactoryException { + ensureNonNull("code", code); + final String KEY = "IdentifiedObject"; + PreparedStatement stmt = statements.get(KEY); // Null allowed. + StringBuilder query = null; // Will be created only if the last statement doesn't suit. + /* + * Iterates through all tables listed in TABLES_INFO, starting with the table used during + * the last call to 'createObject(code)'. This approach assumes that two consecutive calls + * will often return the same type of object. If the object type changed, then this method + * will have to discard the old prepared statement and prepare a new one, which may be a + * costly operation. Only the last successful prepared statement is cached, in order to keep + * the amount of statements low. Unsuccessful statements are immediately disposed. + */ + final String epsg = trimAuthority(code); + final boolean isPrimaryKey = isPrimaryKey(epsg); + final int tupleToSkip = isPrimaryKey ? lastObjectType : -1; + int index = -1; + for (int i = -1; i < TABLES_INFO.length; i++) { + if (i == tupleToSkip) { + // Avoid to test the same table twice. Note that this test also avoid a + // NullPointerException if 'stmt' is null, since 'lastObjectType' should + // be -1 in this case. + continue; + } + try { + if (i >= 0) { + final TableInfo table = TABLES_INFO[i]; + final String column = isPrimaryKey ? table.codeColumn : table.nameColumn; + if (column == null) { + continue; + } + if (query == null) { + query = new StringBuilder("SELECT "); + } + query.setLength(7); // 7 is the length of "SELECT " in the line above. + query.append(table.codeColumn); + query.append(" FROM "); + query.append(table.table); + query.append(" WHERE "); + query.append(column); + query.append(" = ?"); + if (isPrimaryKey) { + assert !statements.containsKey(KEY) : table; + stmt = prepareStatement(KEY, query.toString()); + } else { + // Do not cache the statement for names. + stmt = getConnection().prepareStatement(adaptSQL(query.toString())); + } + } + /* + * Checks if at least one record is found for the code. If the code is the primary + * key, then we will stop at the first table found since a well-formed EPSG database + * should not contains any duplicate identifiers. In the code is a name, then search + * in all tables since duplicate names exist. + */ + stmt.setString(1, epsg); + try (final ResultSet result = stmt.executeQuery()) { + final boolean present = result.next(); + if (present) { + if (index >= 0) { + throw new FactoryException( + Errors.format(ErrorKeys.DUPLICATED_VALUES_$1, code)); + } + index = (i < 0) ? lastObjectType : i; + if (isPrimaryKey) { + // Don't scan other tables, since primary keys should be unique. + // Note that names may be duplicated, so we don't stop for names. + break; + } + } + } + if (isPrimaryKey) { + if (statements.remove(KEY) == null) { + throw new AssertionError(code); // Should never happen. + } + } + stmt.close(); + } catch (SQLException exception) { + throw databaseFailure(IdentifiedObject.class, code, exception); + } + } + /* + * If a record has been found in one table, then delegates to the appropriate method. + */ + if (isPrimaryKey) { + lastObjectType = index; + } + if (index >= 0) { + switch (index) { + case 0: + return createCoordinateReferenceSystem(code); + case 1: + return createCoordinateSystem(code); + case 2: + return createCoordinateSystemAxis(code); + case 3: + return createDatum(code); + case 4: + return createEllipsoid(code); + case 5: + return createPrimeMeridian(code); + case 6: + return createCoordinateOperation(code); + case 7: + return generateOperationMethod(code); + case 8: + return generateParameterDescriptor(code); + case 9: + break; // Can't cast Unit to IdentifiedObject + default: + throw new AssertionError(index); // Should not happen + } + } + return super.createObject(code); + } + + /** + * Returns an unit from a code. + * + * @param code Value allocated by authority. + * @return The unit object. + * @throws NoSuchAuthorityCodeException if this method can't find the requested code. + * @throws FactoryException if some other kind of failure occured in the backing store. This + * exception usually have {@link SQLException} as its cause. + */ + @Override + public synchronized Unit generateUnit(final String code) throws FactoryException { + ensureNonNull("code", code); + Unit returnValue = null; + try { + final String primaryKey = + toPrimaryKey( + Unit.class, code, "[Unit of Measure]", "UOM_CODE", "UNIT_OF_MEAS_NAME"); + final PreparedStatement stmt = + prepareStatement( + "Unit", + "SELECT UOM_CODE," + + " FACTOR_B," + + " FACTOR_C," + + " TARGET_UOM_CODE" + + " FROM [Unit of Measure]" + + " WHERE UOM_CODE = ?"); + stmt.setString(1, primaryKey); + try (ResultSet result = stmt.executeQuery()) { + while (result.next()) { + final int source = getInt(result, 1, code); + final double b = result.getDouble(2); + final double c = result.getDouble(3); + final int target = getInt(result, 4, code); + final Unit base = getUnit(target); + if (base == null) { + throw noSuchAuthorityCode(Unit.class, String.valueOf(target)); + } + Unit unit = getUnit(source); + if (unit == null) { + // TODO: check unit consistency here. + if (b != 0 && c != 0) { + unit = (b == c) ? base : base.multiply(b / c); + } else { + // TODO: provide a localized message. + throw new FactoryException("Unsupported unit: " + code); + } + } + returnValue = ensureSingleton(unit, returnValue, code); + } + } + } catch (SQLException exception) { + throw databaseFailure(Unit.class, code, exception); + } + if (returnValue == null) { + throw noSuchAuthorityCode(Unit.class, code); + } + return returnValue; + } + + /** + * Returns an ellipsoid from a code. + * + * @param code The EPSG value. + * @return The ellipsoid object. + * @throws NoSuchAuthorityCodeException if this method can't find the requested code. + * @throws FactoryException if some other kind of failure occured in the backing store. This + * exception usually have {@link SQLException} as its cause. + */ + @Override + public synchronized Ellipsoid generateEllipsoid(final String code) throws FactoryException { + ensureNonNull("code", code); + Ellipsoid returnValue = null; + try { + final String primaryKey = + toPrimaryKey( + Ellipsoid.class, + code, + "[Ellipsoid]", + "ELLIPSOID_CODE", + "ELLIPSOID_NAME"); + final PreparedStatement stmt = + prepareStatement( + "Ellipsoid", + "SELECT ELLIPSOID_CODE," + + " ELLIPSOID_NAME," + + " SEMI_MAJOR_AXIS," + + " INV_FLATTENING," + + " SEMI_MINOR_AXIS," + + " UOM_CODE," + + " REMARKS" + + " FROM [Ellipsoid]" + + " WHERE ELLIPSOID_CODE = ?"); + stmt.setString(1, primaryKey); + try (ResultSet result = stmt.executeQuery()) { + while (result.next()) { + /* + * One of 'semiMinorAxis' and 'inverseFlattening' values can be NULL in + * the database. Consequently, we don't use 'getString(ResultSet, int)' + * because we don't want to thrown an exception if a NULL value is found. + */ + final String epsg = getString(result, 1, code); + final String name = getString(result, 2, code); + final double semiMajorAxis = getDouble(result, 3, code); + final double inverseFlattening = result.getDouble(4); + final double semiMinorAxis = result.getDouble(5); + final String unitCode = getString(result, 6, code); + final String remarks = result.getString(7); + @SuppressWarnings("unchecked") + final Unit unit = (Unit) createUnit(unitCode); + final Map properties = generateProperties(name, epsg, remarks); + final Ellipsoid ellipsoid; + if (inverseFlattening == 0) { + if (semiMinorAxis == 0) { + // Both are null, which is not allowed. + final String column = result.getMetaData().getColumnName(3); + result.close(); + throw new FactoryException( + Errors.format(ErrorKeys.NULL_VALUE_IN_TABLE_$3, code, column)); + } else { + // We only have semiMinorAxis defined -> it's OK + ellipsoid = + factories + .getDatumFactory() + .createEllipsoid( + properties, semiMajorAxis, semiMinorAxis, unit); + } + } else { + if (semiMinorAxis != 0) { + // Both 'inverseFlattening' and 'semiMinorAxis' are defined. + // Log a warning and create the ellipsoid using the inverse flattening. + final LogRecord record = + Loggings.format( + Level.WARNING, LoggingKeys.AMBIGUOUS_ELLIPSOID, code); + record.setLoggerName(LOGGER.getName()); + LOGGER.log(record); + } + ellipsoid = + factories + .getDatumFactory() + .createFlattenedSphere( + properties, semiMajorAxis, inverseFlattening, unit); + } + /* + * Now that we have built an ellipsoid, compare + * it with the previous one (if any). + */ + returnValue = ensureSingleton(ellipsoid, returnValue, code); + } + } + } catch (SQLException exception) { + throw databaseFailure(Ellipsoid.class, code, exception); + } + if (returnValue == null) { + throw noSuchAuthorityCode(Ellipsoid.class, code); + } + return returnValue; + } + + /** + * Returns a prime meridian, relative to Greenwich. + * + * @param code Value allocated by authority. + * @return The prime meridian object. + * @throws NoSuchAuthorityCodeException if this method can't find the requested code. + * @throws FactoryException if some other kind of failure occured in the backing store. This + * exception usually have {@link SQLException} as its cause. + */ + @Override + public synchronized PrimeMeridian generatePrimeMeridian(final String code) + throws FactoryException { + ensureNonNull("code", code); + PrimeMeridian returnValue = null; + try { + final String primaryKey = + toPrimaryKey( + PrimeMeridian.class, + code, + "[Prime Meridian]", + "PRIME_MERIDIAN_CODE", + "PRIME_MERIDIAN_NAME"); + final PreparedStatement stmt = + prepareStatement( + "PrimeMeridian", + "SELECT PRIME_MERIDIAN_CODE," + + " PRIME_MERIDIAN_NAME," + + " GREENWICH_LONGITUDE," + + " UOM_CODE," + + " REMARKS" + + " FROM [Prime Meridian]" + + " WHERE PRIME_MERIDIAN_CODE = ?"); + stmt.setString(1, primaryKey); + try (ResultSet result = stmt.executeQuery()) { + while (result.next()) { + final String epsg = getString(result, 1, code); + final String name = getString(result, 2, code); + final double longitude = getDouble(result, 3, code); + final String unit_code = getString(result, 4, code); + final String remarks = result.getString(5); + @SuppressWarnings("unchecked") + final Unit unit = + (Unit) createUnit(unit_code); + final Map properties = generateProperties(name, epsg, remarks); + PrimeMeridian primeMeridian = + factories + .getDatumFactory() + .createPrimeMeridian(properties, longitude, unit); + returnValue = ensureSingleton(primeMeridian, returnValue, code); + } + } + } catch (SQLException exception) { + throw databaseFailure(PrimeMeridian.class, code, exception); + } + if (returnValue == null) { + throw noSuchAuthorityCode(PrimeMeridian.class, code); + } + return returnValue; + } + + /** + * Returns an area of use. + * + * @param code Value allocated by authority. + * @return The area of use. + * @throws NoSuchAuthorityCodeException if this method can't find the requested code. + * @throws FactoryException if some other kind of failure occured in the backing store. This + * exception usually have {@link SQLException} as its cause. + */ + public synchronized Extent generateExtent(final String code) throws FactoryException { + ensureNonNull("code", code); + Extent returnValue = null; + try { + final String primaryKey = + toPrimaryKey(Extent.class, code, "[Area]", "AREA_CODE", "AREA_NAME"); + final PreparedStatement stmt = + prepareStatement( + "Area", + "SELECT AREA_OF_USE," + + " AREA_SOUTH_BOUND_LAT," + + " AREA_NORTH_BOUND_LAT," + + " AREA_WEST_BOUND_LON," + + " AREA_EAST_BOUND_LON" + + " FROM [Area]" + + " WHERE AREA_CODE = ?"); + stmt.setString(1, primaryKey); + try (ResultSet result = stmt.executeQuery()) { + while (result.next()) { + ExtentImpl extent = null; + final String description = result.getString(1); + if (description != null) { + extent = new ExtentImpl(); + extent.setDescription(new SimpleInternationalString(description)); + } + final double ymin = result.getDouble(2); + if (!result.wasNull()) { + final double ymax = result.getDouble(3); + if (!result.wasNull()) { + final double xmin = result.getDouble(4); + if (!result.wasNull()) { + final double xmax = result.getDouble(5); + if (!result.wasNull()) { + if (extent == null) { + extent = new ExtentImpl(); + } + extent.setGeographicElements( + Collections.singleton( + new GeographicBoundingBoxImpl( + xmin, xmax, ymin, ymax))); + } + } + } + } + if (extent != null) { + returnValue = + (Extent) ensureSingleton(extent.unmodifiable(), returnValue, code); + } + } + } + } catch (SQLException exception) { + throw databaseFailure(Extent.class, code, exception); + } + if (returnValue == null) { + throw noSuchAuthorityCode(Extent.class, code); + } + return returnValue; + } + + /** + * Returns Bursa-Wolf parameters for a geodetic datum. If the specified datum has no conversion + * informations, then this method will returns {@code null}. + * + * @param code The EPSG code of the {@link GeodeticDatum}. + * @param toClose The result set to close if this method is going to invokes {@link + * #createDatum} recursively. This hack is necessary because many JDBC drivers do not + * support multiple result sets for the same statement. The result set is closed if an only + * if this method returns a non-null value. + * @return an array of Bursa-Wolf parameters (in which case {@code toClose} has been closed), or + * {@code null} (in which case {@code toClose} has not been closed). + */ + private BursaWolfParameters[] generateBursaWolfParameters( + final String code, final ResultSet toClose) throws SQLException, FactoryException { + if (safetyGuard.contains(code)) { + /* + * Do not try to create Bursa-Wolf parameters if the datum is already + * in process of being created. This check avoid never-ending loops in + * recursive call to 'createDatum'. + */ + return null; + } + PreparedStatement stmt = + prepareStatement( + "BursaWolfParametersSet", + "SELECT CO.COORD_OP_CODE," + + " CO.COORD_OP_METHOD_CODE," + + " CRS2.DATUM_CODE" + + " FROM [Coordinate_Operation] AS CO" + + " INNER JOIN [Coordinate Reference System] AS CRS2" + + " ON CO.TARGET_CRS_CODE = CRS2.COORD_REF_SYS_CODE" + + " WHERE CO.COORD_OP_METHOD_CODE >= " + + BURSA_WOLF_MIN_CODE + + " AND CO.COORD_OP_METHOD_CODE <= " + + BURSA_WOLF_MAX_CODE + + " AND CO.COORD_OP_CODE <> " + + DUMMY_OPERATION // GEOT-1008 + + " AND CO.SOURCE_CRS_CODE IN (" + + " SELECT CRS1.COORD_REF_SYS_CODE " // GEOT-1129 + + " FROM [Coordinate Reference System] AS CRS1 " + + " WHERE CRS1.DATUM_CODE = ?)" + + " ORDER BY CRS2.DATUM_CODE," + + " ABS(CO.DEPRECATED), CO.COORD_OP_ACCURACY," + + " CO.COORD_OP_CODE DESC"); // GEOT-846 fix + stmt.setString(1, code); + List bwInfos = null; + try (ResultSet result = stmt.executeQuery()) { + while (result.next()) { + final String operation = getString(result, 1, code); + final int method = getInt(result, 2, code); + final String datum = getString(result, 3, code); + if (bwInfos == null) { + bwInfos = new ArrayList<>(); + } + bwInfos.add(new BursaWolfInfo(operation, method, datum)); + } + } + if (bwInfos == null) { + // Don't close the connection here. + return null; + } + toClose.close(); + /* + * Sorts the infos in preference order. The "ORDER BY" clause above was not enough; + * we also need to take the "supersession" table in account. Once the sorting is done, + * keep only one Bursa-Wolf parameters for each datum. + */ + int size = bwInfos.size(); + if (size > 1) { + final BursaWolfInfo[] codes = bwInfos.toArray(new BursaWolfInfo[size]); + sort(codes); + bwInfos.clear(); + final Set added = new HashSet<>(); + for (final BursaWolfInfo candidate : codes) { + if (added.add(candidate.target)) { + bwInfos.add(candidate); + } + } + size = bwInfos.size(); + } + /* + * We got all the needed informations before to built Bursa-Wolf parameters because the + * 'createDatum(...)' call below may invokes 'createBursaWolfParameters(...)' recursively, + * and not all JDBC drivers supported multi-result set for the same statement. Now, iterate + * throw the results and fetch the parameter values for each BursaWolfParameters object. + */ + stmt = + prepareStatement( + "BursaWolfParameters", + "SELECT PARAMETER_CODE," + + " PARAMETER_VALUE," + + " UOM_CODE" + + " FROM [Coordinate_Operation Parameter Value]" + + " WHERE COORD_OP_CODE = ?" + + " AND COORD_OP_METHOD_CODE = ?"); + for (int i = 0; i < size; i++) { + final BursaWolfInfo info = (BursaWolfInfo) bwInfos.get(i); + final GeodeticDatum datum; + try { + safetyGuard.add(code); + datum = createGeodeticDatum(info.target); + } finally { + safetyGuard.remove(code); + } + final BursaWolfParameters parameters = new BursaWolfParameters(datum); + stmt.setString(1, info.operation); + stmt.setInt(2, info.method); + try (ResultSet result = stmt.executeQuery()) { + while (result.next()) { + setBursaWolfParameter( + parameters, + getInt(result, 1, info.operation), + getDouble(result, 2, info.operation), + createUnit(getString(result, 3, info.operation))); + } + } + if (info.method == ROTATION_FRAME_CODE) { + // Coordinate frame rotation (9607): same as 9606, + // except for the sign of rotation parameters. + parameters.ex = -parameters.ex; + parameters.ey = -parameters.ey; + parameters.ey = -parameters.ey; + } + bwInfos.set(i, parameters); + } + return bwInfos.toArray(new BursaWolfParameters[size]); + } + + /** + * Returns a datum from a code. + * + * @param code Value allocated by authority. + * @return The datum object. + * @throws NoSuchAuthorityCodeException if this method can't find the requested code. + * @throws FactoryException if some other kind of failure occured in the backing store. This + * exception usually have {@link SQLException} as its cause. + * @todo Current implementation maps all "vertical" datum to {@link VerticalDatumType#GEOIDAL}. + * We don't know yet how to maps the exact vertical datum type from the EPSG database. + */ + @Override + public synchronized Datum generateDatum(final String code) throws FactoryException { + ensureNonNull("code", code); + Datum returnValue = null; + try { + final String primaryKey = + toPrimaryKey(Datum.class, code, "[Datum]", "DATUM_CODE", "DATUM_NAME"); + final PreparedStatement stmt = + prepareStatement( + "Datum", + "SELECT DATUM_CODE," + + " DATUM_NAME," + + " DATUM_TYPE," + + " ORIGIN_DESCRIPTION," + + " REALIZATION_EPOCH," + + " AREA_OF_USE_CODE," + + " DATUM_SCOPE," + + " REMARKS," + + " ELLIPSOID_CODE," // Only for geodetic type + + " PRIME_MERIDIAN_CODE" // Only for geodetic type + + " FROM [Datum]" + + " WHERE DATUM_CODE = ?"); + stmt.setString(1, primaryKey); + try (ResultSet result = stmt.executeQuery()) { + boolean exit = false; + while (result.next()) { + final String epsg = getString(result, 1, code); + final String name = getString(result, 2, code); + final String type = getString(result, 3, code).trim().toLowerCase(); + final String anchor = result.getString(4); + final Date epoch = result.getDate(5); + final String area = result.getString(6); + final String scope = result.getString(7); + final String remarks = result.getString(8); + Map properties = + generateProperties(name, epsg, area, scope, remarks); + if (anchor != null) { + properties.put(Datum.ANCHOR_POINT_KEY, anchor); + } + if (epoch != null) + try { + properties.put(Datum.REALIZATION_EPOCH_KEY, epoch); + } catch (NumberFormatException exception) { + // Not a fatal error... + Logging.unexpectedException( + LOGGER, AbstractEpsgFactory.class, "createDatum", exception); + } + final DatumFactory factory = factories.getDatumFactory(); + final Datum datum; + /* + * Now build datum according their datum type. Constructions are straightforward, + * except for the "geodetic" datum type which need some special processing: + * + * - Because it invokes again 'generateProperties' indirectly (through calls to + * 'createEllipsoid' and 'createPrimeMeridian'), it must protect 'properties' + * from changes. + * + * - Because 'createBursaWolfParameters' may invokes 'createDatum' recursively, + * we must close the result set if Bursa-Wolf parameters are found. In this + * case, we lost our paranoiac check for duplication. + */ + if (type.equals("geodetic")) { + properties = new HashMap<>(properties); // Protect from changes + final Ellipsoid ellipsoid = createEllipsoid(getString(result, 9, code)); + final PrimeMeridian meridian = + createPrimeMeridian(getString(result, 10, code)); + final BursaWolfParameters[] param = + generateBursaWolfParameters(primaryKey, result); + + if (param != null) { + exit = true; + properties.put(DefaultGeodeticDatum.BURSA_WOLF_KEY, param); + } + datum = factory.createGeodeticDatum(properties, ellipsoid, meridian); + } else if (type.equals("vertical")) { + // TODO: Find the right datum type. + datum = factory.createVerticalDatum(properties, VerticalDatumType.GEOIDAL); + } else if (type.equals("engineering")) { + datum = factory.createEngineeringDatum(properties); + } else { + result.close(); + throw new FactoryException(Errors.format(ErrorKeys.UNKNOW_TYPE_$1, type)); + } + returnValue = ensureSingleton(datum, returnValue, code); + if (exit) { + // Bypass the 'result.close()' line below: + // the ResultSet has already been closed. + return returnValue; + } + } + } + } catch (SQLException exception) { + throw databaseFailure(Datum.class, code, exception); + } + if (returnValue == null) { + throw noSuchAuthorityCode(Datum.class, code); + } + return returnValue; + } + + /** + * Returns the name and description for the specified {@linkplain CoordinateSystemAxis + * coordinate system axis} code. Many axis share the same name and description, so it is worth + * to cache them. + */ + private AxisName getAxisName(final String code) throws FactoryException { + assert Thread.holdsLock(this); + AxisName returnValue = axisNames.get(code); + if (returnValue == null) + try { + final PreparedStatement stmt = + prepareStatement( + "AxisName", + "SELECT COORD_AXIS_NAME, DESCRIPTION, REMARKS" + + " FROM [Coordinate Axis Name]" + + " WHERE COORD_AXIS_NAME_CODE = ?"); + stmt.setString(1, code); + try (ResultSet result = stmt.executeQuery()) { + while (result.next()) { + final String name = getString(result, 1, code); + String description = result.getString(2); + String remarks = result.getString(3); + if (description == null) { + description = remarks; + } else if (remarks != null) { + description += System.getProperty("line.separator", "\n") + remarks; + } + final AxisName axis = new AxisName(name, description); + returnValue = ensureSingleton(axis, returnValue, code); + } + } + if (returnValue == null) { + throw noSuchAuthorityCode(AxisName.class, code); + } + axisNames.put(code, returnValue); + } catch (SQLException exception) { + throw databaseFailure(AxisName.class, code, exception); + } + return returnValue; + } + + /** + * Returns a {@linkplain CoordinateSystemAxis coordinate system axis} from a code. + * + * @param code Value allocated by authority. + * @throws NoSuchAuthorityCodeException if the specified {@code code} was not found. + * @throws FactoryException if the object creation failed for some other reason. + */ + @Override + public synchronized CoordinateSystemAxis generateCoordinateSystemAxis(final String code) + throws FactoryException { + ensureNonNull("code", code); + CoordinateSystemAxis returnValue = null; + try { + final PreparedStatement stmt = + prepareStatement( + "Axis", + "SELECT COORD_AXIS_CODE," + + " COORD_AXIS_NAME_CODE," + + " COORD_AXIS_ORIENTATION," + + " COORD_AXIS_ABBREVIATION," + + " UOM_CODE" + + " FROM [Coordinate Axis]" + + " WHERE COORD_AXIS_CODE = ?"); + stmt.setString(1, code); + try (ResultSet result = stmt.executeQuery()) { + while (result.next()) { + final String epsg = getString(result, 1, code); + final String nameCode = getString(result, 2, code); + final String orientation = getString(result, 3, code); + final String abbreviation = getString(result, 4, code); + final String unit = getString(result, 5, code); + AxisDirection direction; + try { + direction = DefaultCoordinateSystemAxis.getDirection(orientation); + } catch (NoSuchElementException exception) { + if (orientation.equalsIgnoreCase("Geocentre > equator/PM")) { + direction = AxisDirection.OTHER; // TODO: can we choose a more accurate + // direction? + } else if (orientation.equalsIgnoreCase("Geocentre > equator/90dE")) { + direction = AxisDirection.EAST; + } else if (orientation.equalsIgnoreCase("Geocentre > north pole")) { + direction = AxisDirection.NORTH; + } else { + throw new FactoryException(exception); + } + } + final AxisName an = getAxisName(nameCode); + final Map properties = + generateProperties(an.name, epsg, an.description); + final CSFactory factory = factories.getCSFactory(); + final CoordinateSystemAxis axis = + factory.createCoordinateSystemAxis( + properties, abbreviation, direction, createUnit(unit)); + returnValue = ensureSingleton(axis, returnValue, code); + } + } + } catch (SQLException exception) { + throw databaseFailure(CoordinateSystemAxis.class, code, exception); + } + if (returnValue == null) { + throw noSuchAuthorityCode(CoordinateSystemAxis.class, code); + } + return returnValue; + } + + /** + * Returns the coordinate system axis from an EPSG code for a {@link CoordinateSystem}. + * + *

WARNING: The EPSG database uses "{@code ORDER}" as a column name. This is + * tolerated by Access, but MySQL doesn't accept this name. + * + * @param code the EPSG code for coordinate system owner. + * @param dimension of the coordinate system, which is also the size of the returned array. + * @return An array of coordinate system axis. + * @throws SQLException if an error occured during database access. + * @throws FactoryException if the code has not been found. + */ + private CoordinateSystemAxis[] generateAxisForCoordinateSystem( + final String code, final int dimension) throws SQLException, FactoryException { + assert Thread.holdsLock(this); + final CoordinateSystemAxis[] axis = new CoordinateSystemAxis[dimension]; + final PreparedStatement stmt = + prepareStatement( + "AxisOrder", + "SELECT COORD_AXIS_CODE" + + " FROM [Coordinate Axis]" + + " WHERE COORD_SYS_CODE = ?" + + " ORDER BY [ORDER]"); + // WARNING: Be careful about the column name : + // MySQL rejects ORDER as a column name !!! + stmt.setString(1, code); + int i = 0; + try (ResultSet result = stmt.executeQuery()) { + while (result.next()) { + final String axisCode = getString(result, 1, code); + if (i < axis.length) { + // If 'i' is out of bounds, an exception will be thrown after the loop. + // We don't want to thrown an ArrayIndexOutOfBoundsException here. + axis[i] = createCoordinateSystemAxis(axisCode); + } + ++i; + } + } + if (i != axis.length) { + throw new FactoryException( + Errors.format(ErrorKeys.MISMATCHED_DIMENSION_$2, axis.length, i)); + } + return axis; + } + + /** + * Returns a coordinate system from a code. + * + * @param code Value allocated by authority. + * @return The coordinate system object. + * @throws NoSuchAuthorityCodeException if this method can't find the requested code. + * @throws FactoryException if some other kind of failure occured in the backing store. This + * exception usually have {@link SQLException} as its cause. + */ + @Override + public synchronized CoordinateSystem generateCoordinateSystem(final String code) + throws FactoryException { + ensureNonNull("code", code); + CoordinateSystem returnValue = null; + final PreparedStatement stmt; + try { + final String primaryKey = + toPrimaryKey( + CoordinateSystem.class, + code, + "[Coordinate System]", + "COORD_SYS_CODE", + "COORD_SYS_NAME"); + stmt = + prepareStatement( + "CoordinateSystem", + "SELECT COORD_SYS_CODE," + + " COORD_SYS_NAME," + + " COORD_SYS_TYPE," + + " DIMENSION," + + " REMARKS" + + " FROM [Coordinate System]" + + " WHERE COORD_SYS_CODE = ?"); + stmt.setString(1, primaryKey); + try (ResultSet result = stmt.executeQuery()) { + while (result.next()) { + final String epsg = getString(result, 1, code); + final String name = getString(result, 2, code); + final String type = getString(result, 3, code).trim().toLowerCase(); + final int dimension = getInt(result, 4, code); + final String remarks = result.getString(5); + final CoordinateSystemAxis[] axis = + generateAxisForCoordinateSystem(primaryKey, dimension); + final Map properties = + generateProperties(name, epsg, remarks); // Must be after axis + final CSFactory factory = factories.getCSFactory(); + CoordinateSystem cs = null; + if (type.equals("ellipsoidal")) { + switch (dimension) { + case 2: + cs = factory.createEllipsoidalCS(properties, axis[0], axis[1]); + break; + case 3: + cs = + factory.createEllipsoidalCS( + properties, axis[0], axis[1], axis[2]); + break; + } + } else if (type.equals("cartesian")) { + switch (dimension) { + case 2: + cs = factory.createCartesianCS(properties, axis[0], axis[1]); + break; + case 3: + cs = + factory.createCartesianCS( + properties, axis[0], axis[1], axis[2]); + break; + } + } else if (type.equals("spherical")) { + switch (dimension) { + case 3: + cs = + factory.createSphericalCS( + properties, axis[0], axis[1], axis[2]); + break; + } + } else if (type.equals("vertical") || type.equals("gravity-related")) { + switch (dimension) { + case 1: + cs = factory.createVerticalCS(properties, axis[0]); + break; + } + } else if (type.equals("linear")) { + switch (dimension) { + case 1: + cs = factory.createLinearCS(properties, axis[0]); + break; + } + } else if (type.equals("polar")) { + switch (dimension) { + case 2: + cs = factory.createPolarCS(properties, axis[0], axis[1]); + break; + } + } else if (type.equals("cylindrical")) { + switch (dimension) { + case 3: + cs = + factory.createCylindricalCS( + properties, axis[0], axis[1], axis[2]); + break; + } + } else if (type.equals("affine")) { + switch (dimension) { + case 2: + cs = factory.createAffineCS(properties, axis[0], axis[1]); + break; + case 3: + cs = factory.createAffineCS(properties, axis[0], axis[1], axis[2]); + break; + } + } else { + result.close(); + throw new FactoryException(Errors.format(ErrorKeys.UNKNOW_TYPE_$1, type)); + } + if (cs == null) { + result.close(); + throw new FactoryException( + Errors.format(ErrorKeys.UNEXPECTED_DIMENSION_FOR_CS_$1, type)); + } + returnValue = ensureSingleton(cs, returnValue, code); + } + } + } catch (SQLException exception) { + throw databaseFailure(CoordinateSystem.class, code, exception); + } + if (returnValue == null) { + throw noSuchAuthorityCode(CoordinateSystem.class, code); + } + return returnValue; + } + + /** + * Returns the primary key for a coordinate reference system name. This method is used both by + * {@link #createCoordinateReferenceSystem} and {@link + * #createFromCoordinateReferenceSystemCodes} + */ + private String toPrimaryKeyCRS(final String code) throws SQLException, FactoryException { + return toPrimaryKey( + CoordinateReferenceSystem.class, + code, + "[Coordinate Reference System]", + "COORD_REF_SYS_CODE", + "COORD_REF_SYS_NAME"); + } + + /** + * Returns a coordinate reference system from a code. + * + * @param code Value allocated by authority. + * @return The coordinate reference system object. + * @throws NoSuchAuthorityCodeException if this method can't find the requested code. + * @throws FactoryException if some other kind of failure occured in the backing store. This + * exception usually have {@link SQLException} as its cause. + */ + @Override + public synchronized CoordinateReferenceSystem generateCoordinateReferenceSystem( + final String code) throws FactoryException { + ensureNonNull("code", code); + CoordinateReferenceSystem returnValue = null; + try { + final String primaryKey = toPrimaryKeyCRS(code); + final PreparedStatement stmt = + prepareStatement( + "CoordinateReferenceSystem", + "SELECT COORD_REF_SYS_CODE," + + " COORD_REF_SYS_NAME," + + " AREA_OF_USE_CODE," + + " CRS_SCOPE," + + " REMARKS," + + " COORD_REF_SYS_KIND," + + " COORD_SYS_CODE," // Null for CompoundCRS + + " DATUM_CODE," // Null for ProjectedCRS + + " SOURCE_GEOGCRS_CODE," // For ProjectedCRS + + " PROJECTION_CONV_CODE," // For ProjectedCRS + + " CMPD_HORIZCRS_CODE," // For CompoundCRS only + + " CMPD_VERTCRS_CODE" // For CompoundCRS only + + " FROM [Coordinate Reference System]" + + " WHERE COORD_REF_SYS_CODE = ?"); + stmt.setString(1, primaryKey); + boolean exit = false; + try (ResultSet result = stmt.executeQuery()) { + while (result.next()) { + final String epsg = getString(result, 1, code); + final String name = getString(result, 2, code); + final String area = result.getString(3); + final String scope = result.getString(4); + final String remarks = result.getString(5); + final String type = getString(result, 6, code); + // Note: Do not invoke 'generateProperties' now, even if we have all required + // informations, because the 'properties' map is going to overwritten + // by calls to 'createDatum', 'createCoordinateSystem', etc. + final CRSFactory factory = factories.getCRSFactory(); + final CoordinateReferenceSystem crs; + /* ---------------------------------------------------------------------- + * GEOGRAPHIC CRS + * + * NOTE: 'generateProperties' MUST be invoked after any call to an other + * 'createFoo' method. Consequently, do not factor out. + * ---------------------------------------------------------------------- */ + if (type.equalsIgnoreCase("geographic 2D") + || type.equalsIgnoreCase("geographic 3D")) { + final String csCode = getString(result, 7, code); + final String dmCode = result.getString(8); + final EllipsoidalCS cs = createEllipsoidalCS(csCode); + final GeodeticDatum datum; + if (dmCode != null) { + datum = createGeodeticDatum(dmCode); + } else { + final String geoCode = getString(result, 9, code, 8); + result.close(); // Must be close before createGeographicCRS + exit = true; + final GeographicCRS baseCRS = createGeographicCRS(geoCode); + datum = baseCRS.getDatum(); + } + final Map properties = + generateProperties(name, epsg, area, scope, remarks); + crs = factory.createGeographicCRS(properties, datum, cs); + } + /* ---------------------------------------------------------------------- + * PROJECTED CRS + * + * NOTE: This method invokes itself indirectly, through createGeographicCRS. + * Consequently, we can't use 'result' anymore. We must close it here. + * ---------------------------------------------------------------------- */ + else if (type.equalsIgnoreCase("projected")) { + final String csCode = getString(result, 7, code); + final String geoCode = getString(result, 9, code); + final String opCode = getString(result, 10, code); + result.close(); // Must be close before createGeographicCRS + exit = true; + final CartesianCS cs = createCartesianCS(csCode); + final GeographicCRS baseCRS = createGeographicCRS(geoCode); + final CoordinateOperation op = createCoordinateOperation(opCode); + if (op instanceof Conversion) { + final Map properties = + generateProperties(name, epsg, area, scope, remarks); + crs = + factory.createProjectedCRS( + properties, baseCRS, (Conversion) op, cs); + } else { + throw noSuchAuthorityCode(Projection.class, opCode); + } + } + /* ---------------------------------------------------------------------- + * VERTICAL CRS + * ---------------------------------------------------------------------- */ + else if (type.equalsIgnoreCase("vertical")) { + final String csCode = getString(result, 7, code); + final String dmCode = getString(result, 8, code); + final VerticalCS cs = createVerticalCS(csCode); + final VerticalDatum datum = createVerticalDatum(dmCode); + final Map properties = + generateProperties(name, epsg, area, scope, remarks); + crs = factory.createVerticalCRS(properties, datum, cs); + } + /* ---------------------------------------------------------------------- + * COMPOUND CRS + * + * NOTE: This method invokes itself recursively. + * Consequently, we can't use 'result' anymore. + * ---------------------------------------------------------------------- */ + else if (type.equalsIgnoreCase("compound")) { + final String code1 = getString(result, 11, code); + final String code2 = getString(result, 12, code); + result.close(); + exit = true; + final CoordinateReferenceSystem crs1, crs2; + if (!safetyGuard.add(epsg)) { + throw recursiveCall(CompoundCRS.class, epsg); + } + try { + crs1 = createCoordinateReferenceSystem(code1); + crs2 = createCoordinateReferenceSystem(code2); + } finally { + safetyGuard.remove(epsg); + } + // Note: Don't invoke 'generateProperties' sooner. + final Map properties = + generateProperties(name, epsg, area, scope, remarks); + crs = factory.createCompoundCRS(properties, crs1, crs2); + } + /* ---------------------------------------------------------------------- + * GEOCENTRIC CRS + * ---------------------------------------------------------------------- */ + else if (type.equalsIgnoreCase("geocentric")) { + final String csCode = getString(result, 7, code); + final String dmCode = getString(result, 8, code); + final CoordinateSystem cs = createCoordinateSystem(csCode); + final GeodeticDatum datum = createGeodeticDatum(dmCode); + final Map properties = + generateProperties(name, epsg, area, scope, remarks); + if (cs instanceof CartesianCS) { + crs = factory.createGeocentricCRS(properties, datum, (CartesianCS) cs); + } else if (cs instanceof SphericalCS) { + crs = factory.createGeocentricCRS(properties, datum, (SphericalCS) cs); + } else { + result.close(); + throw new FactoryException( + Errors.format( + ErrorKeys.ILLEGAL_COORDINATE_SYSTEM_FOR_CRS_$2, + cs.getClass(), + GeocentricCRS.class)); + } + } + /* ---------------------------------------------------------------------- + * ENGINEERING CRS + * ---------------------------------------------------------------------- */ + else if (type.equalsIgnoreCase("engineering")) { + final String csCode = getString(result, 7, code); + final String dmCode = getString(result, 8, code); + final CoordinateSystem cs = createCoordinateSystem(csCode); + final EngineeringDatum datum = createEngineeringDatum(dmCode); + final Map properties = + generateProperties(name, epsg, area, scope, remarks); + crs = factory.createEngineeringCRS(properties, datum, cs); + } + /* ---------------------------------------------------------------------- + * UNKNOW CRS + * ---------------------------------------------------------------------- */ + else { + result.close(); + throw new FactoryException(Errors.format(ErrorKeys.UNKNOW_TYPE_$1, type)); + } + returnValue = ensureSingleton(crs, returnValue, code); + if (exit) { + // Bypass the 'result.close()' line below: + // the ResultSet has already been closed. + return returnValue; + } + } + } + } catch (SQLException exception) { + throw databaseFailure(CoordinateReferenceSystem.class, code, exception); + } + if (returnValue == null) { + throw noSuchAuthorityCode(CoordinateReferenceSystem.class, code); + } + return returnValue; + } + + /** + * Returns a parameter descriptor from a code. + * + * @param code The parameter descriptor code allocated by EPSG authority. + * @throws NoSuchAuthorityCodeException if this method can't find the requested code. + * @throws FactoryException if some other kind of failure occured in the backing store. This + * exception usually have {@link SQLException} as its cause. + */ + public synchronized ParameterDescriptor generateParameterDescriptor(final String code) + throws FactoryException { + ensureNonNull("code", code); + ParameterDescriptor returnValue = null; + final PreparedStatement stmt; + try { + final String primaryKey = + toPrimaryKey( + ParameterDescriptor.class, + code, + "[Coordinate_Operation Parameter]", + "PARAMETER_CODE", + "PARAMETER_NAME"); + stmt = + prepareStatement( + "ParameterDescriptor", // Must be singular form. + "SELECT PARAMETER_CODE," + + " PARAMETER_NAME," + + " DESCRIPTION" + + " FROM [Coordinate_Operation Parameter]" + + " WHERE PARAMETER_CODE = ?"); + stmt.setString(1, primaryKey); + try (ResultSet result = stmt.executeQuery()) { + while (result.next()) { + final String epsg = getString(result, 1, code); + final String name = getString(result, 2, code); + final String remarks = result.getString(3); + final Unit unit; + final Class type; + /* + * Search for units. We will choose the most commonly used one in parameter values. + * If the parameter appears to have at least one non-null value in the "Parameter + * File Name" column, then the type is assumed to be URI. Otherwise, the type is a + * floating point number. + */ + final PreparedStatement units = + prepareStatement( + "ParameterUnit", + "SELECT MIN(UOM_CODE) AS UOM," + + " MIN(PARAM_VALUE_FILE_REF) AS FILEREF" + + " FROM [Coordinate_Operation Parameter Value]" + + " WHERE (PARAMETER_CODE = ?)" + + " GROUP BY UOM_CODE" + + " ORDER BY COUNT(UOM_CODE) DESC"); + units.setString(1, epsg); + try (final ResultSet resultUnits = units.executeQuery()) { + if (resultUnits.next()) { + String element = resultUnits.getString(1); + unit = (element != null) ? createUnit(element) : null; + element = resultUnits.getString(2); + type = + (element != null && element.trim().length() != 0) + ? URI.class + : double.class; + } else { + unit = null; + type = double.class; + } + } + /* + * Now creates the parameter descriptor. + */ + final Map properties = generateProperties(name, epsg, remarks); + @SuppressWarnings("unchecked") + final ParameterDescriptor descriptor = + new DefaultParameterDescriptor( + properties, type, null, null, null, null, unit, true); + returnValue = ensureSingleton(descriptor, returnValue, code); + } + } + } catch (SQLException exception) { + throw databaseFailure(OperationMethod.class, code, exception); + } + if (returnValue == null) { + throw noSuchAuthorityCode(OperationMethod.class, code); + } + return returnValue; + } + + /** + * Returns all parameter descriptors for the specified method. + * + * @param method The operation method code. + * @return The parameter descriptors. + * @throws SQLException if a SQL statement failed. + */ + private ParameterDescriptor[] generateParameterDescriptors(final String method) + throws FactoryException, SQLException { + final PreparedStatement stmt = + prepareStatement( + "ParameterDescriptors", // Must be plural form. + "SELECT PARAMETER_CODE" + + " FROM [Coordinate_Operation Parameter Usage]" + + " WHERE COORD_OP_METHOD_CODE = ?" + + " ORDER BY SORT_ORDER"); + stmt.setString(1, method); + try (ResultSet results = stmt.executeQuery()) { + final List> descriptors = new ArrayList<>(); + while (results.next()) { + final String param = getString(results, 1, method); + descriptors.add(generateParameterDescriptor(param)); + } + return descriptors.toArray(new ParameterDescriptor[descriptors.size()]); + } + } + + /** + * Fill parameter values in the specified group. + * + * @param method The EPSG code for the operation method. + * @param operation The EPSG code for the operation (conversion or transformation). + * @param parameters The parameter values to fill. + * @throws SQLException if a SQL statement failed. + */ + private void fillParameterValues( + final String method, final String operation, final ParameterValueGroup parameters) + throws FactoryException, SQLException { + final PreparedStatement stmt = + prepareStatement( + "ParameterValues", + "SELECT CP.PARAMETER_NAME," + + " CV.PARAMETER_VALUE," + + " CV.PARAM_VALUE_FILE_REF," + + " CV.UOM_CODE" + + " FROM ([Coordinate_Operation Parameter Value] AS CV" + + " INNER JOIN [Coordinate_Operation Parameter] AS CP" + + " ON CV.PARAMETER_CODE = CP.PARAMETER_CODE)" + + " INNER JOIN [Coordinate_Operation Parameter Usage] AS CU" + + " ON (CP.PARAMETER_CODE = CU.PARAMETER_CODE)" + + " AND (CV.COORD_OP_METHOD_CODE = CU.COORD_OP_METHOD_CODE)" + + " WHERE CV.COORD_OP_METHOD_CODE = ?" + + " AND CV.COORD_OP_CODE = ?" + + " ORDER BY CU.SORT_ORDER"); + stmt.setString(1, method); + stmt.setString(2, operation); + try (ResultSet result = stmt.executeQuery()) { + while (result.next()) { + final String name = getString(result, 1, operation); + final double value = result.getDouble(2); + final Unit unit; + Object reference; + if (result.wasNull()) { + /* + * If no numeric values were provided in the database, then the values must + * appears in some external file. It may be a file to download from FTP. + */ + reference = getString(result, 3, operation); + try { + reference = new URI((String) reference); + } catch (URISyntaxException exception) { + // Ignore: we will stores the reference as a file. + reference = new File((String) reference); + } + unit = null; + } else { + reference = null; + final String unitCode = result.getString(4); + unit = (unitCode != null) ? createUnit(unitCode) : null; + } + final ParameterValue param; + try { + param = parameters.parameter(name); + } catch (ParameterNotFoundException exception) { + /* + * Wraps the unchecked ParameterNotFoundException into the checked + * NoSuchIdentifierException, which is a FactoryException subclass. + * Note that in theory, NoSuchIdentifierException is for MathTransforms rather + * than parameters. However, we are close in spirit here since we are setting + * up MathTransform's parameters. Using NoSuchIdentifierException allows users + * (including CoordinateOperationSet) to know that the failure is probably + * caused by a MathTransform not yet supported in Geotools (or only partially + * supported) rather than some more serious failure in the database side. + * CoordinateOperationSet uses this information in order to determine if it + * should try the next coordinate operation or propagate the exception. + */ + final NoSuchIdentifierException e = + new NoSuchIdentifierException( + Errors.format(ErrorKeys.CANT_SET_PARAMETER_VALUE_$1, name), + name); + e.initCause(exception); + throw e; + } + try { + if (reference != null) { + param.setValue(reference); + } else if (unit != null) { + param.setValue(value, unit); + } else { + param.setValue(value); + } + } catch (InvalidParameterValueException exception) { + throw new FactoryException( + Errors.format(ErrorKeys.CANT_SET_PARAMETER_VALUE_$1, name), exception); + } + } + } + } + + /** + * Returns an operation method from a code. + * + * @param code The operation method code allocated by EPSG authority. + * @throws NoSuchAuthorityCodeException if this method can't find the requested code. + * @throws FactoryException if some other kind of failure occured in the backing store. This + * exception usually have {@link SQLException} as its cause. + */ + public synchronized OperationMethod generateOperationMethod(final String code) + throws FactoryException { + ensureNonNull("code", code); + OperationMethod returnValue = null; + final PreparedStatement stmt; + try { + final String primaryKey = + toPrimaryKey( + OperationMethod.class, + code, + "[Coordinate_Operation Method]", + "COORD_OP_METHOD_CODE", + "COORD_OP_METHOD_NAME"); + stmt = + prepareStatement( + "OperationMethod", + "SELECT COORD_OP_METHOD_CODE," + + " COORD_OP_METHOD_NAME," + + " FORMULA," + + " REMARKS" + + " FROM [Coordinate_Operation Method]" + + " WHERE COORD_OP_METHOD_CODE = ?"); + stmt.setString(1, primaryKey); + try (ResultSet result = stmt.executeQuery()) { + OperationMethod method = null; + while (result.next()) { + final String epsg = getString(result, 1, code); + final String name = getString(result, 2, code); + final String formula = result.getString(3); + final String remarks = result.getString(4); + final int encoded = getDimensionsForMethod(epsg); + final int sourceDimensions = encoded >>> 16; + final int targetDimensions = encoded & 0xFFFF; + final ParameterDescriptor[] descriptors = generateParameterDescriptors(epsg); + final Map properties = generateProperties(name, epsg, remarks); + if (formula != null) { + properties.put(OperationMethod.FORMULA_KEY, formula); + } + method = + new DefaultOperationMethod( + properties, + sourceDimensions, + targetDimensions, + new DefaultParameterDescriptorGroup(properties, descriptors)); + returnValue = ensureSingleton(method, returnValue, code); + } + } + } catch (SQLException exception) { + throw databaseFailure(OperationMethod.class, code, exception); + } + if (returnValue == null) { + throw noSuchAuthorityCode(OperationMethod.class, code); + } + return returnValue; + } + + /** + * Returns the must common source and target dimensions for the specified method. Source + * dimension is encoded in the 16 highest bits and target dimension is encoded in the 16 lowest + * bits. If this method can't infers the dimensions from the "Coordinate Operation" table, then + * the operation method is probably a projection, which always have (2,2) dimensions in the EPSG + * database. + */ + private int getDimensionsForMethod(final String code) throws SQLException { + final PreparedStatement stmt = + prepareStatement( + "MethodDimensions", + "SELECT SOURCE_CRS_CODE," + + " TARGET_CRS_CODE" + + " FROM [Coordinate_Operation]" + + " WHERE COORD_OP_METHOD_CODE = ?" + + " AND SOURCE_CRS_CODE IS NOT NULL" + + " AND TARGET_CRS_CODE IS NOT NULL"); + stmt.setString(1, code); + final Map dimensions = new HashMap<>(); + final Dimensions temp = new Dimensions((2 << 16) | 2); // Default to (2,2) dimensions. + Dimensions max = temp; + try (ResultSet result = stmt.executeQuery()) { + while (result.next()) { + final short sourceDimensions = getDimensionForCRS(result.getString(1)); + final short targetDimensions = getDimensionForCRS(result.getString(2)); + temp.encoded = (sourceDimensions << 16) | (targetDimensions); + Dimensions candidate = dimensions.get(temp); + if (candidate == null) { + candidate = new Dimensions(temp.encoded); + dimensions.put(candidate, candidate); + } + if (++candidate.occurences > max.occurences) { + max = candidate; + } + } + } + return max.encoded; + } + + /** A counter for source and target dimensions (to be kept together). */ + private static final class Dimensions { + /** The dimensions as an encoded value. */ + int encoded; + /** The occurences of this dimensions. */ + int occurences; + + Dimensions(final int e) { + encoded = e; + } + + @Override + public int hashCode() { + return encoded; + } + + @Override + public boolean equals(final Object object) { // MUST ignore 'occurences'. + return (object instanceof Dimensions) && ((Dimensions) object).encoded == encoded; + } + + @Override + public String toString() { + return "[(" + + (encoded >>> 16) + + ',' + + (encoded & 0xFFFF) + + ")\u00D7" + + occurences + + ']'; + } + } + + /** + * Returns the dimension of the specified CRS. If the CRS is not found (which should not happen, + * but we don't need to be strict here), then this method assumes a two-dimensional CRS. + */ + private short getDimensionForCRS(final String code) throws SQLException { + final PreparedStatement stmt; + final Short cached = axisCounts.get(code); + final short dimension; + if (cached == null) { + stmt = + prepareStatement( + "Dimension", + " SELECT COUNT(COORD_AXIS_CODE)" + + " FROM [Coordinate Axis]" + + " WHERE COORD_SYS_CODE = (SELECT COORD_SYS_CODE " + + " FROM [Coordinate Reference System]" + + " WHERE COORD_REF_SYS_CODE = ?)"); + stmt.setString(1, code); + try (ResultSet result = stmt.executeQuery()) { + dimension = result.next() ? result.getShort(1) : 2; + axisCounts.put(code, dimension); + } + } else { + dimension = cached.shortValue(); + } + return dimension; + } + + /** + * Returns {@code true} if the {@linkplain CoordinateOperation coordinate operation} for the + * specified code is a {@linkplain Projection projection}. The caller must have ensured that the + * designed operation is a {@linkplain Conversion conversion} before to invoke this method. + */ + final synchronized boolean isProjection(final String code) throws SQLException { + final PreparedStatement stmt; + Boolean projection = codeProjection.get(code); + if (projection == null) { + stmt = + prepareStatement( + "isProjection", + "SELECT COORD_REF_SYS_CODE" + + " FROM [Coordinate Reference System]" + + " WHERE PROJECTION_CONV_CODE = ?" + + " AND COORD_REF_SYS_KIND LIKE 'projected%'"); + stmt.setString(1, code); + try (ResultSet result = stmt.executeQuery()) { + final boolean found = result.next(); + projection = Boolean.valueOf(found); + codeProjection.put(code, projection); + } + } + return projection.booleanValue(); + } + + /** + * Returns a coordinate operation from a code. The returned object will either be a {@linkplain + * Conversion conversion} or a {@linkplain Transformation transformation}, depending on the + * code. + * + * @param code Value allocated by authority. + * @return The coordinate operation object. + * @throws NoSuchAuthorityCodeException if this method can't find the requested code. + * @throws FactoryException if some other kind of failure occured in the backing store. This + * exception usually have {@link SQLException} as its cause. + */ + @Override + public synchronized CoordinateOperation generateCoordinateOperation(final String code) + throws FactoryException { + ensureNonNull("code", code); + CoordinateOperation returnValue = null; + try { + final String primaryKey = + toPrimaryKey( + CoordinateOperation.class, + code, + "[Coordinate_Operation]", + "COORD_OP_CODE", + "COORD_OP_NAME"); + final PreparedStatement stmt = + prepareStatement( + "CoordinateOperation", + "SELECT COORD_OP_CODE," + + " COORD_OP_NAME," + + " COORD_OP_TYPE," + + " SOURCE_CRS_CODE," + + " TARGET_CRS_CODE," + + " COORD_OP_METHOD_CODE," + + " COORD_TFM_VERSION," + + " COORD_OP_ACCURACY," + + " AREA_OF_USE_CODE," + + " COORD_OP_SCOPE," + + " REMARKS" + + " FROM [Coordinate_Operation]" + + " WHERE COORD_OP_CODE = ?"); + stmt.setString(1, primaryKey); + boolean exit = false; + try (ResultSet result = stmt.executeQuery()) { + while (result.next()) { + final String epsg = getString(result, 1, code); + final String name = getString(result, 2, code); + final String type = getString(result, 3, code).trim().toLowerCase(); + final boolean isTransformation = type.equals("transformation"); + final boolean isConversion = type.equals("conversion"); + final boolean isConcatenated = type.equals("concatenated operation"); + final String sourceCode, targetCode, methodCode; + if (isConversion) { + // Optional for conversions, mandatory for all others. + sourceCode = result.getString(4); + targetCode = result.getString(5); + } else { + sourceCode = getString(result, 4, code); + targetCode = getString(result, 5, code); + } + if (isConcatenated) { + // Not applicable to concatenated operation, mandatory for all others. + methodCode = result.getString(6); + } else { + methodCode = getString(result, 6, code); + } + String version = result.getString(7); + double accuracy = result.getDouble(8); + if (result.wasNull()) accuracy = Double.NaN; + String area = result.getString(9); + String scope = result.getString(10); + String remarks = result.getString(11); + /* + * Gets the source and target CRS. They are mandatory for transformations (it + * was checked above in this method) and optional for conversions. Conversions + * are usually "defining conversions" and don't define source and target CRS. + * In EPSG database 6.7, all defining conversions are projections and their + * dimensions are always 2. However, this is not generalizable to other kind + * of operation methods. For example the "Geocentric translation" operation + * method has 3-dimensional source and target. + */ + final int sourceDimensions, targetDimensions; + final CoordinateReferenceSystem sourceCRS, targetCRS; + if (sourceCode != null) { + sourceCRS = createCoordinateReferenceSystem(sourceCode); + sourceDimensions = sourceCRS.getCoordinateSystem().getDimension(); + } else { + sourceCRS = null; + sourceDimensions = 2; // Acceptable default for projections only. + } + if (targetCode != null) { + targetCRS = createCoordinateReferenceSystem(targetCode); + targetDimensions = targetCRS.getCoordinateSystem().getDimension(); + } else { + targetCRS = null; + targetDimensions = 2; // Acceptable default for projections only. + } + /* + * Gets the operation method. This is mandatory for conversions and transformations + * (it was checked above in this method) but optional for concatenated operations. + * Fetching parameter values is part of this block. + */ + final boolean isBursaWolf; + OperationMethod method; + final ParameterValueGroup parameters; + if (methodCode == null) { + isBursaWolf = false; + method = null; + parameters = null; + } else { + final int num; + try { + num = Integer.parseInt(methodCode); + } catch (NumberFormatException exception) { + result.close(); + throw new FactoryException(exception); + } + isBursaWolf = (num >= BURSA_WOLF_MIN_CODE && num <= BURSA_WOLF_MAX_CODE); + // Reminder: The source and target dimensions MUST be computed when + // the information is available. Dimension is not always 2!! + method = generateOperationMethod(methodCode); + if (method.getSourceDimensions() != sourceDimensions + || method.getTargetDimensions() != targetDimensions) { + method = + new DefaultOperationMethod( + method, sourceDimensions, targetDimensions); + } + /* + * Note that some parameters required for MathTransform creation are implicit in + * the EPSG database (e.g. semi-major and semi-minor axis length in the case of + * map projections). We ask the parameter value group straight from the math + * transform factory instead of from the operation method in order to get all + * required parameter descriptors, including implicit ones. + */ + final String classe = method.getName().getCode(); + parameters = + factories.getMathTransformFactory().getDefaultParameters(classe); + fillParameterValues(methodCode, epsg, parameters); + } + /* + * Creates common properties. The 'version' and 'accuracy' are usually defined + * for transformations only. However, we check them for all kind of operations + * (including conversions) and copy the information inconditionnaly if present. + * + * NOTE: This block must be executed last before object creations below, because + * methods like createCoordinateReferenceSystem and createOperationMethod + * overwrite the properties map. + */ + final Map properties = + generateProperties(name, epsg, area, scope, remarks); + if (version != null && (version = version.trim()).length() != 0) { + properties.put(CoordinateOperation.OPERATION_VERSION_KEY, version); + } + if (!Double.isNaN(accuracy)) { + final QuantitativeResultImpl accuracyResult = + new QuantitativeResultImpl(new double[] {accuracy}); + // TODO: Need to invoke something equivalent to: + // accuracyResult.setValueType(Float.class); + // This is the type declared in the MS-Access database. + accuracyResult.setValueUnit( + SI.METRE); // In meters by definition in the EPSG database. + final AbsoluteExternalPositionalAccuracyImpl accuracyElement = + new AbsoluteExternalPositionalAccuracyImpl(accuracyResult); + accuracyElement.setMeasureDescription(TRANSFORMATION_ACCURACY); + accuracyElement.setEvaluationMethodType( + EvaluationMethodType.DIRECT_EXTERNAL); + properties.put( + CoordinateOperation.COORDINATE_OPERATION_ACCURACY_KEY, + new PositionalAccuracy[] { + (PositionalAccuracy) accuracyElement.unmodifiable() + }); + } + /* + * Creates the operation. Conversions should be the only operations allowed to + * have null source and target CRS. In such case, the operation is a defining + * conversion (usually to be used later as part of a ProjectedCRS creation), + * and always a projection in the specific case of the EPSG database (which + * allowed us to assume 2-dimensional operation method in the code above for + * this specific case - not to be generalized to the whole EPSG database). + */ + final CoordinateOperation operation; + if (isConversion && (sourceCRS == null || targetCRS == null)) { + // Note: we usually can't resolve sourceCRS and targetCRS because there + // is many of them for the same coordinate operation (projection) code. + operation = new DefiningConversion(properties, method, parameters); + } else if (isConcatenated) { + /* + * Concatenated operation: we need to close the current result set, because + * we are going to invoke this method recursively in the following lines. + * + * Note: we instantiate directly the Geotools's implementation of + * ConcatenatedOperation instead of using CoordinateOperationFactory in order + * to avoid loading the quite large Geotools's implementation of this factory, + * and also because it is not part of FactoryGroup anyway. + */ + result.close(); + exit = true; + final PreparedStatement cstmt = + prepareStatement( + "ConcatenatedOperation", + "SELECT SINGLE_OPERATION_CODE" + + " FROM [Coordinate_Operation Path]" + + " WHERE (CONCAT_OPERATION_CODE = ?)" + + " ORDER BY OP_PATH_STEP"); + cstmt.setString(1, epsg); + final List codes = new ArrayList<>(); + try (ResultSet cr = cstmt.executeQuery()) { + while (cr.next()) { + codes.add(cr.getString(1)); + } + } + final CoordinateOperation[] operations = + new CoordinateOperation[codes.size()]; + if (!safetyGuard.add(epsg)) { + throw recursiveCall(ConcatenatedOperation.class, epsg); + } + try { + for (int i = 0; i < operations.length; i++) { + operations[i] = createCoordinateOperation(codes.get(i)); + } + } finally { + safetyGuard.remove(epsg); + } + try { + return new DefaultConcatenatedOperation(properties, operations); + } catch (IllegalArgumentException exception) { + // May happen if there is less than 2 operations to concatenate. + // It happen for some deprecated CRS like 8658 for example. + throw new FactoryException(exception); + } + } else { + /* + * Needs to create a math transform. A special processing is performed for + * datum shift methods, since the conversion from ellipsoid to geocentric + * for "geocentric translations" is implicit in the EPSG database. Even in + * the case of Molodenski transforms, the axis length to set are the same. + */ + if (isBursaWolf) + try { + Ellipsoid ellipsoid = CRSUtilities.getHeadGeoEllipsoid(sourceCRS); + if (ellipsoid != null) { + final Unit axisUnit = ellipsoid.getAxisUnit(); + parameters + .parameter("src_semi_major") + .setValue(ellipsoid.getSemiMajorAxis(), axisUnit); + parameters + .parameter("src_semi_minor") + .setValue(ellipsoid.getSemiMinorAxis(), axisUnit); + parameters + .parameter("src_dim") + .setValue( + sourceCRS.getCoordinateSystem().getDimension()); + } + ellipsoid = CRSUtilities.getHeadGeoEllipsoid(targetCRS); + if (ellipsoid != null) { + final Unit axisUnit = ellipsoid.getAxisUnit(); + parameters + .parameter("tgt_semi_major") + .setValue(ellipsoid.getSemiMajorAxis(), axisUnit); + parameters + .parameter("tgt_semi_minor") + .setValue(ellipsoid.getSemiMinorAxis(), axisUnit); + parameters + .parameter("tgt_dim") + .setValue( + targetCRS.getCoordinateSystem().getDimension()); + } + } catch (ParameterNotFoundException exception) { + result.close(); + throw new FactoryException( + Errors.format( + ErrorKeys.GEOTOOLS_EXTENSION_REQUIRED_$1, + method.getName().getCode(), + exception)); + } + /* + * At this stage, the parameters are ready for use. Creates the math transform + * and wraps it in the final operation (a Conversion or a Transformation). + */ + final Class expected; + if (isTransformation) { + expected = Transformation.class; + } else if (isConversion) { + expected = Conversion.class; + } else { + result.close(); + throw new FactoryException( + Errors.format(ErrorKeys.UNKNOW_TYPE_$1, type)); + } + final MathTransform mt = + factories + .getMathTransformFactory() + .createBaseToDerived( + sourceCRS, + parameters, + targetCRS.getCoordinateSystem()); + // TODO: uses GeoAPI factory method once available. + operation = + DefaultOperation.create( + properties, sourceCRS, targetCRS, mt, method, expected); + } + returnValue = ensureSingleton(operation, returnValue, code); + if (exit) { + // Bypass the 'result.close()' line below: + // the ResultSet has already been closed. + return returnValue; + } + } + } + } catch (SQLException exception) { + throw databaseFailure(CoordinateOperation.class, code, exception); + } + if (returnValue == null) { + throw noSuchAuthorityCode(CoordinateOperation.class, code); + } + return returnValue; + } + + /** + * Creates operations from coordinate reference system codes. The returned set is ordered with + * the most accurate operations first. + * + * @param sourceCode Coded value of source coordinate reference system. + * @param targetCode Coded value of target coordinate reference system. + * @throws FactoryException if the object creation failed. + * @todo The ordering is not consistent among all database software, because the "accuracy" + * column may contains null values. When used in an "ORDER BY" clause, PostgreSQL put null + * values last, while Access and HSQL put them first. The PostgreSQL's behavior is better + * for what we want (put operations with unknow accuracy last). Unfortunatly, I don't know + * yet how to instruct Access to put null values last using standard SQL ("IIF" is not + * standard, and Access doesn't seem to understand "CASE ... THEN" clauses). + */ + @Override + public synchronized Set generateFromCoordinateReferenceSystemCodes( + final String sourceCode, final String targetCode) throws FactoryException { + ensureNonNull("sourceCode", sourceCode); + ensureNonNull("targetCode", targetCode); + final String pair = sourceCode + " \u21E8 " + targetCode; + final CoordinateOperationSet set = new CoordinateOperationSet(this); + try { + final String sourceKey = toPrimaryKeyCRS(sourceCode); + final String targetKey = toPrimaryKeyCRS(targetCode); + boolean searchTransformations = false; + do { + /* + * This 'do' loop is executed twice: the first time for searching defining + * conversions, and the second time for searching all other kind of operations. + * Defining conversions are searched first because they are, by definition, the + * most accurate operations. + */ + final String key, sql; + if (searchTransformations) { + key = "TransformationFromCRS"; + sql = + "SELECT COORD_OP_CODE" + + " FROM [Coordinate_Operation]" + + " WHERE SOURCE_CRS_CODE = ?" + + " AND TARGET_CRS_CODE = ?" + + " ORDER BY ABS(DEPRECATED), COORD_OP_ACCURACY"; + } else { + key = "ConversionFromCRS"; + sql = + "SELECT PROJECTION_CONV_CODE" + + " FROM [Coordinate Reference System]" + + " WHERE SOURCE_GEOGCRS_CODE = ?" + + " AND COORD_REF_SYS_CODE = ?"; + } + final PreparedStatement stmt = prepareStatement(key, sql); + stmt.setString(1, sourceKey); + stmt.setString(2, targetKey); + try (ResultSet result = stmt.executeQuery()) { + while (result.next()) { + final String code = getString(result, 1, pair); + set.addAuthorityCode(code, searchTransformations ? null : targetKey); + } + } + } while ((searchTransformations = !searchTransformations) == true); + /* + * Search finished. We may have a lot of coordinate operations + * (e.g. about 40 for "ED50" (EPSG:4230) to "WGS 84" (EPSG:4326)). + * Alter the ordering using the information supplied in the supersession table. + */ + final String[] codes = set.getAuthorityCodes(); + sort(codes); + set.setAuthorityCodes(codes); + } catch (SQLException exception) { + throw databaseFailure(CoordinateOperation.class, pair, exception); + } + /* + * Before to return the set, tests the creation of 1 object in order to report early + * (i.e. now) any problems with SQL statements. Remaining operations will be created + * only when first needed. + */ + set.resolve(1); + return set; + } + + /** + * Sorts an array of codes in preference order. This method orders pairwise the codes according + * the information provided in the supersession table. If the same object is superseded by more + * than one object, then the most recent one is inserted first. Except for the codes moved as a + * result of pairwise ordering, this method try to preserve the old ordering of the supplied + * codes (since deprecated operations should already be last). The ordering is performed in + * place. + * + * @param codes The codes, usually as an array of {@link String}. If the array do not contains + * string objects, then the {@link Object#toString} method must returns the code for each + * element. + */ + // TODO: Use generic type for "Object[] codes" with J2SE 1.5. + private void sort(final Object... codes) throws SQLException, FactoryException { + if (codes.length <= 1) { + return; // Nothing to sort. + } + final PreparedStatement stmt = + prepareStatement( + "Supersession", + "SELECT SUPERSEDED_BY" + + " FROM [Supersession]" + + " WHERE OBJECT_CODE = ?" + + " ORDER BY SUPERSESSION_YEAR DESC"); + int maxIterations = 15; // For avoiding never-ending loop. + do { + boolean changed = false; + for (int i = 0; i < codes.length; i++) { + final String code = codes[i].toString(); + stmt.setString(1, code); + try (ResultSet result = stmt.executeQuery()) { + while (result.next()) { + final String replacement = getString(result, 1, code); + for (int j = i + 1; j < codes.length; j++) { + final Object candidate = codes[j]; + if (replacement.equals(candidate.toString())) { + /* + * Found a code to move in front of the superceded one. + */ + System.arraycopy(codes, i, codes, i + 1, j - i); + codes[i++] = candidate; + changed = true; + } + } + } + } + } + if (!changed) { + return; + } + } while (--maxIterations != 0); + LOGGER.finer("Possible recursivity in supersessions."); + } + + /** + * An implementation of {@link IdentifiedObjectFinder} which scans over a smaller set of + * authority codes. + * + *

Implementation note: Since this method may be invoked indirectly by {@link + * LongitudeFirstFactory}, it must be insensitive to axis order. + */ + private final class Finder extends IdentifiedObjectFinder { + /** Creates a new finder backed by the specified buffered authority factory. */ + Finder(final Class type) { + super(AbstractEpsgFactory.this, type); + } + + /** + * Returns a set of authority codes that may identify the same object than + * the specified one. This implementation tries to get a smaller set than what {@link + * AbstractEpsgFactory#getAuthorityCodes} would produce. + */ + @Override + protected Set getCodeCandidates(final IdentifiedObject object) + throws FactoryException { + String select = "COORD_REF_SYS_CODE"; + String from = "[Coordinate Reference System]"; + String where, code; + if (object instanceof Ellipsoid) { + select = "ELLIPSOID_CODE"; + from = "[Ellipsoid]"; + where = "SEMI_MAJOR_AXIS"; + code = Double.toString(((Ellipsoid) object).getSemiMajorAxis()); + } else { + IdentifiedObject dependency; + if (object instanceof GeneralDerivedCRS) { + dependency = ((GeneralDerivedCRS) object).getBaseCRS(); + where = "SOURCE_GEOGCRS_CODE"; + } else if (object instanceof SingleCRS) { + dependency = ((SingleCRS) object).getDatum(); + where = "DATUM_CODE"; + } else if (object instanceof GeodeticDatum) { + dependency = ((GeodeticDatum) object).getEllipsoid(); + select = "DATUM_CODE"; + from = "[Datum]"; + where = "ELLIPSOID_CODE"; + } else { + return super.getCodeCandidates(object); + } + dependency = getIdentifiedObjectFinder(dependency.getClass()).find(dependency); + Identifier id = AbstractIdentifiedObject.getIdentifier(dependency, getAuthority()); + if (id == null || (code = id.getCode()) == null) { + return super.getCodeCandidates(object); + } + } + String sql = + "SELECT " + select + " FROM " + from + " WHERE " + where + "='" + code + '\''; + sql = adaptSQL(sql); + final Set result = new LinkedHashSet<>(); + try (Statement s = getConnection().createStatement(); + ResultSet r = s.executeQuery(sql)) { + while (r.next()) { + result.add(r.getString(1)); + } + } catch (SQLException exception) { + throw databaseFailure(Identifier.class, code, exception); + } + return result; + } + } + + /** Constructs an exception for recursive calls. */ + private static FactoryException recursiveCall( + final Class type, final String code) { + return new FactoryException(Errors.format(ErrorKeys.RECURSIVE_CALL_$2, type, code)); + } + + /** Constructs an exception for a database failure. */ + private static FactoryException databaseFailure( + final Class type, final String code, final SQLException cause) { + return new FactoryException( + Errors.format(ErrorKeys.DATABASE_FAILURE_$2, type, code), cause); + } + + /** + * Invoked when a new {@link PreparedStatement} is about to be created from a SQL string. Since + * the EPSG database is available mainly in MS-Access format, + * SQL statements are formatted using some syntax specific to this particular database software + * (for example "SELECT * FROM [Coordinate Reference System]"). When prociding + * subclass targeting another database vendor, then this method should be overridden in order to + * adapt the local SQL syntax. + * + *

For example a subclass connecting to a PostgreSQL database could replace all + * spaces (" ") between watching braces ("[" and "]") by underscore ("_"). + * + * @param statement The statement in MS-Access syntax. + * @return The SQL statement to use. The default implementation returns the string unchanged. + */ + protected abstract String adaptSQL(final String statement); + + /** + * Returns {@code true} if the specified code may be a primary key in some table. This method do + * not needs to checks any entry in the database. It should just checks from the syntax if the + * code looks like a valid EPSG identifier. The default implementation returns {@code true} if + * all non-space characters are {@linkplain Character#isDigit(char) digits}. + * + *

When this method returns {@code false}, some {@code createFoo(...)} methods look for the + * code in the name column instead of the primary key column. This allows to accept the + * "NTF (Paris) / France I" string (for example) in addition to the {@code "27581"} + * primary key. Both should fetch the same object. + * + *

If this method returns {@code true} in all cases, then this factory never search for + * matching names. In such case, an appropriate exception will be thrown in {@code + * createFoo(...)} methods if the code is not found in the primary key column. Subclasses can + * overrides this method that way if this is the intended behavior. + * + * @param code The code the inspect. + * @return {@code true} if the code is probably a primary key. + * @throws FactoryException if an unexpected error occured while inspecting the code. + */ + protected boolean isPrimaryKey(final String code) throws FactoryException { + final int length = code.length(); + for (int i = 0; i < length; i++) { + final char c = code.charAt(i); + if (!Character.isDigit(c) && !Character.isSpaceChar(c)) { + return false; + } + } + return true; + } + + /** + * Returns {@code true} if it is safe to dispose this factory. This method is invoked indirectly + * by {@link ThreadedEpsgFactory} after some timeout in order to release resources. This method + * will block the disposal if some {@linkplain #getAuthorityCodes set of authority codes} are + * still in use. + */ + final synchronized boolean canDispose() { + return true; + } + + /** + * Disposes any resources hold by this object. + * + * @throws FactoryException if an error occurred while closing the connection. + */ + @Override + public synchronized void dispose() throws FactoryException { + disconnect(); + super.dispose(); + } + + /** Connect to the database in anticipation of of use. */ + public void connect() throws FactoryException { + try { + getConnection(); + } catch (SQLException e) { + throw new FactoryException(e); + } + } + /** + * Disconnect from the database, and remain idle. We will still keep our internal data + * structures, we are not going to hold onto a database connection unless we are going to be + * used. + */ + public void disconnect() throws FactoryException { + if (connection != null) { + final boolean isClosed; + try { + isClosed = connection.isClosed(); + for (final Iterator it = statements.values().iterator(); + it.hasNext(); ) { + (it.next()).close(); + it.remove(); + } + connection.close(); + } catch (SQLException exception) { + throw new FactoryException(exception); + } + if (!isClosed) { + /* + * The above code was run unconditionally as a safety, even if the connection + * was already closed. However we will log a message only if we actually closed + * the connection, otherwise the log records are a little bit misleading. + */ + final LogRecord record = + Loggings.format(Level.FINE, LoggingKeys.CLOSED_EPSG_DATABASE); + record.setLoggerName(LOGGER.getName()); + LOGGER.log(record); + } + connection = null; + } + } + + /** + * Access to the connection used by this EpsgFactory. The connection will be created as needed. + * + * @return the connection + */ + protected synchronized Connection getConnection() throws SQLException { + if (connection == null) { + connection = dataSource.getConnection(); + } + return connection; + } + /** + * Shutdown the database engine. This method is invoked twice by {@link ThreadedEpsgFactory} at + * JVM shutdown: one time before the {@linkplain #connection} is closed, and a second time + * after. This shutdown hook is useful for embedded database engine starting a + * server process in addition to the client process. Just closing the connection is not enough + * for them. Example: + * + *

+ * + *

    + *
  • HSQL database engine needs to execute a {@code "SHUTDOWN"} statement using the + * {@linkplain #connection} before it is closed. + *
  • Derby database engine needs to instruct the {@linkplain java.sql.DriverManager driver + * manager} after all connections have been closed. + *
+ * + *

The default implementation does nothing, which is sufficient for implementations + * connecting to a distant server (i.e. non-embedded database engine), for example {@linkplain + * AccessDataSource MS-Access} or {@linkplain PostgreDataSource PostgreSQL}. + * + * @param active {@code true} if the {@linkplain #connection} is alive, or {@code false} + * otherwise. This method is invoked first with {@code active} set to {@code true}, then a + * second time with {@code active} set to {@code false}. + * @throws SQLException if this method failed to shutdown the database engine. + */ + protected void shutdown(final boolean active) throws SQLException {} + + /** + * Invokes {@link #dispose} when this factory is garbage collected. + * + * @throws Throwable if an error occurred while closing the connection. + */ + @Override + @SuppressWarnings("deprecation") // finalize is deprecated in Java 9 + protected final void finalize() throws Throwable { + dispose(); + super.finalize(); + } + + ////////////////////////////////////////////////////////////////////////////////////////////// + ////// /////// + ////// HARD CODED VALUES (other than SQL statements) RELATIVE TO THE EPSG DATABASE /////// + ////// /////// + ////////////////////////////////////////////////////////////////////////////////////////////// + /** + * Returns a hard-coded unit from an EPSG code. We do not need to provide all units here, but we + * must at least provide all base units declared in the [TARGET_UOM_CODE] column of table [Unit + * of Measure]. Other units will be derived automatically if they are not listed here. + * + * @param code The code. + * @return The unit, or {@code null} if the code is unrecognized. + */ + private static Unit getUnit(final int code) { + switch (code) { + case 9001: + return METRE; + case 9002: + return FOOT; + case 9030: + return NAUTICAL_MILE; + case 9036: + return KILOMETER; + case 9101: + return RADIAN; + case 9122: // Fall through + case 9102: + return DEGREE_ANGLE; + case 9103: + return MINUTE_ANGLE; + case 9104: + return SECOND_ANGLE; + case 9105: + return GRADE; + case 9107: + return DEGREE_MINUTE_SECOND; + case 9108: + return DEGREE_MINUTE_SECOND; + case 9109: + return MICRORADIAN; + case 9110: + return SEXAGESIMAL_DMS; + // TODO case 9111: return NonSI.SEXAGESIMAL_DM; + case 9203: // Fall through + case 9201: + return ONE; + case 9202: + return PPM; + default: + return null; + } + } + + /** + * Set a Bursa-Wolf parameter from an EPSG parameter. + * + * @param parameters The Bursa-Wolf parameters to modify. + * @param code The EPSG code for a parameter from [PARAMETER_CODE] column. + * @param value The value of the parameter from [PARAMETER_VALUE] column. + * @param unit The unit of the parameter value from [UOM_CODE] column. + * @throws FactoryException if the code is unrecognized. + * @throws IllegalArgumentException if the value could not be converted to the provided Unit + */ + private static void setBursaWolfParameter( + final BursaWolfParameters parameters, final int code, double value, final Unit unit) + throws FactoryException { + Unit target = unit; + if (code >= 8605) { + if (code <= 8607) target = SI.METRE; + else if (code == 8611) target = Units.PPM; + else if (code <= 8710) target = NonSI.SECOND_ANGLE; + } + if (target != unit) { + value = Units.getConverterToAny(unit, target).convert(value); + } + switch (code) { + case 8605: + parameters.dx = value; + break; + case 8606: + parameters.dy = value; + break; + case 8607: + parameters.dz = value; + break; + case 8608: + parameters.ex = value; + break; + case 8609: + parameters.ey = value; + break; + case 8610: + parameters.ez = value; + break; + case 8611: + parameters.ppm = value; + break; + default: + throw new FactoryException(Errors.format(ErrorKeys.UNEXPECTED_PARAMETER_$1, code)); + } + } + + /** + * List of tables and columns to test for codes values. This table is used by the {@link + * #createObject} method in order to detect which of the following methods should be invoked for + * a given code: + * + *

{@link #createCoordinateReferenceSystem} {@link #createCoordinateSystem} {@link + * #createDatum} {@link #createEllipsoid} {@link #createUnit} + * + *

The order is significant: it is the key for a {@code switch} statement. + * + * @see #createObject + * @see #lastObjectType + */ + private static final TableInfo[] TABLES_INFO = { + new TableInfo( + CoordinateReferenceSystem.class, + "[Coordinate Reference System]", + "COORD_REF_SYS_CODE", + "COORD_REF_SYS_NAME", + "COORD_REF_SYS_KIND", + new Class[] {ProjectedCRS.class, GeographicCRS.class, GeocentricCRS.class}, + new String[] {"projected", "geographic", "geocentric"}), + new TableInfo( + CoordinateSystem.class, + "[Coordinate System]", + "COORD_SYS_CODE", + "COORD_SYS_NAME", + "COORD_SYS_TYPE", + new Class[] { + CartesianCS.class, EllipsoidalCS.class, SphericalCS.class, VerticalCS.class + }, + new String[] {"Cartesian", "ellipsoidal", "spherical", "vertical"}), + new TableInfo( + CoordinateSystemAxis.class, + "[Coordinate Axis] AS CA INNER JOIN [Coordinate Axis Name] AS CAN" + + " ON CA.COORD_AXIS_NAME_CODE=CAN.COORD_AXIS_NAME_CODE", + "COORD_AXIS_CODE", + "COORD_AXIS_NAME"), + new TableInfo( + Datum.class, + "[Datum]", + "DATUM_CODE", + "DATUM_NAME", + "DATUM_TYPE", + new Class[] {GeodeticDatum.class, VerticalDatum.class, EngineeringDatum.class}, + new String[] {"geodetic", "vertical", "engineering"}), + new TableInfo(Ellipsoid.class, "[Ellipsoid]", "ELLIPSOID_CODE", "ELLIPSOID_NAME"), + new TableInfo( + PrimeMeridian.class, + "[Prime Meridian]", + "PRIME_MERIDIAN_CODE", + "PRIME_MERIDIAN_NAME"), + new TableInfo( + CoordinateOperation.class, + "[Coordinate_Operation]", + "COORD_OP_CODE", + "COORD_OP_NAME", + "COORD_OP_TYPE", + new Class[] {Projection.class, Conversion.class, Transformation.class}, + new String[] {"conversion", "conversion", "transformation"}), + // Note: Projection is handle in a special way. + + new TableInfo( + OperationMethod.class, + "[Coordinate_Operation Method]", + "COORD_OP_METHOD_CODE", + "COORD_OP_METHOD_NAME"), + new TableInfo( + ParameterDescriptor.class, + "[Coordinate_Operation Parameter]", + "PARAMETER_CODE", + "PARAMETER_NAME"), + new TableInfo(Unit.class, "[Unit of Measure]", "UOM_CODE", "UNIT_OF_MEAS_NAME") + }; + + /////////////////////////////////////////////////////////////////////////////// + //////// //////// + //////// E N D O F H A R D C O D E D V A L U E S //////// + //////// //////// + //////// NOTE: 'createFoo(...)' methods may still have hard-coded //////// + //////// values (others than SQL statements) in 'equalsIgnoreCase' //////// + //////// expressions. //////// + /////////////////////////////////////////////////////////////////////////////// + /** + * A set of EPSG authority codes. This set makes use of our connection to the EPSG database. All + * {@link #iterator} method call creates a new {@link ResultSet} holding the codes. However, + * call to {@link #contains} map directly to a SQL call. + * + *

Serialization of this class store a copy of all authority codes. The serialization do not + * preserve any connection to the database. + * + * @since 2.2 + * @version $Id$ + * @author Martin Desruisseaux (IRD) + */ + final class AuthorityCodeSet extends AbstractSet implements Serializable { + /** For compatibility with different versions. */ + private static final long serialVersionUID = 7105664579449680562L; + + /** + * The type for this code set. This is translated to the most appropriate interface type + * even if the user supplied an implementation type. + */ + public final Class type; + + /** {@code true} if {@link #type} is assignable to {@link Projection}. */ + private final boolean isProjection; + + /** + * A view of this set as a map with object's name as values, or {@code null} if none. Will + * be created only when first needed. + */ + private transient java.util.Map asMap; + + /** + * The SQL command to use for creating the {@code queryAll} statement. Used for iteration + * over all codes. + */ + final String sqlAll; + + /** + * The SQL command to use for creating the {@code querySingle} statement. Used for fetching + * the description from a code. + */ + private final String sqlSingle; + + /** The statement to use for querying all codes. Will be created only when first needed. */ + private transient PreparedStatement queryAll; + + /** + * The statement to use for querying a single code. Will be created only when first needed. + */ + private transient PreparedStatement querySingle; + + /** + * The collection's size, or a negative value if not yet computed. The records will be + * counted only when first needed. The special value -2 if set by {@link #isEmpty} if the + * size has not yet been computed, but we know that the set is not empty. + */ + private int size = -1; + + /** + * Creates a new set of authority codes for the specified type. + * + * @param table The table to query. + * @param type The type to query. + */ + public AuthorityCodeSet(final TableInfo table, final Class type) { + final StringBuilder buffer = new StringBuilder("SELECT "); + buffer.append(table.codeColumn); + if (table.nameColumn != null) { + buffer.append(", ").append(table.nameColumn); + } + buffer.append(" FROM ").append(table.table); + boolean hasWhere = false; + Class tableType = table.type; + if (table.typeColumn != null) { + for (int i = 0; i < table.subTypes.length; i++) { + final Class candidate = table.subTypes[i]; + if (candidate.isAssignableFrom(type)) { + buffer.append(" WHERE (") + .append(table.typeColumn) + .append(" LIKE '") + .append(table.typeNames[i]) + .append("%'"); + hasWhere = true; + tableType = candidate; + break; + } + } + if (hasWhere) { + buffer.append(')'); + } + } + this.type = tableType; + isProjection = Projection.class.isAssignableFrom(tableType); + final int length = buffer.length(); + buffer.append(" ORDER BY ").append(table.codeColumn); + sqlAll = adaptSQL(buffer.toString()); + buffer.setLength(length); + buffer.append(hasWhere ? " AND " : " WHERE ").append(table.codeColumn).append(" = ?"); + sqlSingle = adaptSQL(buffer.toString()); + } + + /** Returns all codes. */ + private ResultSet getAll() throws SQLException { + assert Thread.holdsLock(this); + if (queryAll != null) { + try { + return queryAll.executeQuery(); + } catch (SQLException ignore) { + /* + * Failed to reuse an existing statement. This problem occurs in some occasions + * with the JDBC-ODBC bridge in Java 6 (the error message is "Invalid handle"). + * I'm not sure where the bug come from (didn't noticed it when using HSQL). We + * will try again with a new statement created in the code after this 'catch' + * clause. Note that we set 'queryAll' to null first in case of failure during + * the 'prepareStatement(...)' execution. + */ + queryAll.close(); + queryAll = null; + recoverableException("getAll", ignore); + } + } + queryAll = getConnection().prepareStatement(sqlAll); + return queryAll.executeQuery(); + } + + /** Returns a single code. */ + private ResultSet getSingle(final Object code) throws SQLException { + assert Thread.holdsLock(this); + if (querySingle == null) { + querySingle = getConnection().prepareStatement(sqlSingle); + } + querySingle.setString(1, code.toString()); + return querySingle.executeQuery(); + } + + /** + * Returns {@code true} if the code in the specified result set is acceptable. This method + * handle projections in a special way. + */ + private boolean isAcceptable(final ResultSet results) throws SQLException { + if (!isProjection) { + return true; + } + final String code = results.getString(1); + return isProjection(code); + } + + /** + * Returns {@code true} if the code in the specified code is acceptable. This method handle + * projections in a special way. + */ + private boolean isAcceptable(final String code) throws SQLException { + if (!isProjection) { + return true; + } + return isProjection(code); + } + + /** + * Returns {@code true} if this collection contains no elements. This method fetch at most + * one row instead of counting all rows. + */ + @Override + public synchronized boolean isEmpty() { + if (size != -1) { + return size == 0; + } + boolean empty = true; + try { + try (ResultSet results = getAll()) { + while (results.next()) { + if (isAcceptable(results)) { + empty = false; + break; + } + } + } + } catch (SQLException exception) { + unexpectedException("isEmpty", exception); + } + size = empty ? 0 : -2; + return empty; + } + + /** Count the number of elements in the underlying result set. */ + @Override + public synchronized int size() { + if (size >= 0) { + return size; + } + int count = 0; + try { + try (ResultSet results = getAll()) { + while (results.next()) { + if (isAcceptable(results)) { + count++; + } + } + } + } catch (SQLException exception) { + unexpectedException("size", exception); + } + size = count; // Stores only on success. + return count; + } + + /** Returns {@code true} if this collection contains the specified element. */ + @Override + public synchronized boolean contains(final Object code) { + boolean exists = false; + if (code != null) + try { + try (ResultSet results = getSingle(code)) { + while (results.next()) { + if (isAcceptable(results)) { + exists = true; + break; + } + } + } + } catch (SQLException exception) { + unexpectedException("contains", exception); + } + return exists; + } + + /** + * Returns an iterator over the codes. The iterator is backed by a living {@link ResultSet}, + * which will be closed as soon as the iterator reach the last element. + */ + @Override + public synchronized java.util.Iterator iterator() { + try { + final Iterator iterator = new Iterator(getAll()); + /* + * Set the statement to null without closing it, in order to force a new statement + * creation if getAll() is invoked before the iterator finish its iteration. This + * is needed because only one ResultSet is allowed for each Statement. + */ + queryAll = null; + return iterator; + } catch (SQLException exception) { + unexpectedException("iterator", exception); + final Set empty = Collections.emptySet(); + return empty.iterator(); + } + } + + /** + * Returns a serializable copy of this set. This method is invoked automatically during + * serialization. The serialised set of authority code is disconnected from the underlying + * database. + */ + protected LinkedHashSet writeReplace() throws ObjectStreamException { + return new LinkedHashSet<>(this); + } + + /** + * Closes the underlying statements. Note: this method is also invoked directly by {@link + * DirectEpsgFactory#dispose}, which is okay in this particular case since the + * implementation of this method can be executed an arbitrary amount of times. + */ + @Override + @SuppressWarnings("deprecation") // finalize is deprecated in Java 9 + protected synchronized void finalize() throws SQLException { + if (querySingle != null) { + querySingle.close(); + querySingle = null; + } + if (queryAll != null) { + queryAll.close(); + queryAll = null; + } + } + + /** Invoked when an exception occured. This method just log a warning. */ + private void unexpectedException(final String method, final SQLException exception) { + unexpectedException(AuthorityCodes.class, method, exception); + } + + /** Invoked when an exception occured. This method just log a warning. */ + void unexpectedException( + final Class classe, final String method, final SQLException exception) { + Logging.unexpectedException(LOGGER, classe, method, exception); + } + + /** Invoked when a recoverable exception occured. */ + private void recoverableException(final String method, final SQLException exception) { + // Uses the FINE level instead of WARNING because it may be a recoverable error. + LogRecord record = Loggings.format(Level.FINE, LoggingKeys.UNEXPECTED_EXCEPTION); + record.setSourceClassName(AuthorityCodes.class.getName()); + record.setSourceMethodName(method); + record.setThrown(exception); + record.setLoggerName(LOGGER.getName()); + LOGGER.log(record); + } + + /** + * The iterator over the codes. This inner class must kept a reference toward the enclosing + * {@link AuthorityCodes} in order to prevent a call to {@link AuthorityCodes#finalize} + * before the iteration is finished. + */ + private final class Iterator implements java.util.Iterator { + /** The result set, or {@code null} if there is no more elements. */ + private ResultSet results; + + /** The next code. */ + private transient String next; + + /** Creates a new iterator for the specified result set. */ + Iterator(final ResultSet results) throws SQLException { + assert Thread.holdsLock(AuthorityCodeSet.this); + this.results = results; + toNext(); + } + + /** Moves to the next element. */ + private void toNext() throws SQLException { + while (results.next()) { + next = results.getString(1); + if (isAcceptable(next)) { + return; + } + } + finalize(); + } + + /** Returns {@code true} if there is more elements. */ + @Override + public boolean hasNext() { + return results != null; + } + + /** Returns the next element. */ + @Override + public String next() { + if (results == null) { + throw new NoSuchElementException(); + } + final String current = next; + try { + toNext(); + } catch (SQLException exception) { + results = null; + unexpectedException(Iterator.class, "next", exception); + } + return current; + } + + /** Always throws an exception, since this iterator is read-only. */ + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + /** Closes the underlying result set. */ + @Override + @SuppressWarnings("deprecation") // finalize is deprecated in Java 9 + protected void finalize() throws SQLException { + next = null; + if (results != null) { + final PreparedStatement owner = (PreparedStatement) results.getStatement(); + results.close(); + results = null; + synchronized (AuthorityCodeSet.this) { + /* + * We don't need the statement anymore. Gives it back to the enclosing class + * in order to avoid creating a new one when AuthorityCodes.getAll() will be + * invoked again, or closes the statement if getAll() already created a new + * statement anyway. + */ + assert owner != queryAll; + if (queryAll == null) { + queryAll = owner; + } else { + owner.close(); + } + } + } + } + } + + /** + * Returns a view of this set as a map with object's name as value, or {@code null} if none. + */ + final java.util.Map asMap() { + if (asMap == null) { + asMap = new Map(); + } + return asMap; + } + + /** + * A view of {@link AuthorityCodes} as a map, with authority codes as key and object names + * as values. + */ + private final class Map extends AbstractMap { + /** Returns the number of key-value mappings in this map. */ + @Override + public int size() { + return AuthorityCodeSet.this.size(); + } + + /** Returns {@code true} if this map contains no key-value mappings. */ + @Override + public boolean isEmpty() { + return AuthorityCodeSet.this.isEmpty(); + } + + /** Returns the description to which this map maps the specified EPSG code. */ + @Override + public String get(final Object code) { + String value = null; + if (code != null) + try { + synchronized (AuthorityCodeSet.this) { + try (ResultSet results = getSingle(code)) { + while (results.next()) { + if (isAcceptable(results)) { + value = results.getString(2); + break; + } + } + } + } + } catch (SQLException exception) { + unexpectedException("get", exception); + } + return value; + } + + /** Returns {@code true} if this map contains a mapping for the specified EPSG code. */ + @Override + public boolean containsKey(final Object key) { + return contains(key); + } + + /** Returns a set view of the keys contained in this map. */ + @Override + public Set keySet() { + return AuthorityCodeSet.this; + } + + /** + * Returns a set view of the mappings contained in this map. + * + * @todo Not yet implemented. + */ + @Override + public Set> entrySet() { + throw new UnsupportedOperationException(); + } + } + } +}