|
|
@@ -0,0 +1,4973 @@
|
|
|
+/*
|
|
|
+ * GeoTools - The Open Source Java GIS Toolkit
|
|
|
+ * http://geotools.org
|
|
|
+ *
|
|
|
+ * (C) 2002-2016, 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.jdbc;
|
|
|
+
|
|
|
+import static org.geotools.jdbc.VirtualTable.WHERE_CLAUSE_PLACE_HOLDER;
|
|
|
+import static org.geotools.jdbc.VirtualTable.WHERE_CLAUSE_PLACE_HOLDER_LENGTH;
|
|
|
+import static org.geotools.jdbc.VirtualTable.setKeepWhereClausePlaceHolderHint;
|
|
|
+
|
|
|
+import java.io.IOException;
|
|
|
+import java.io.UnsupportedEncodingException;
|
|
|
+import java.lang.reflect.Method;
|
|
|
+import java.net.URLDecoder;
|
|
|
+import java.sql.Connection;
|
|
|
+import java.sql.DatabaseMetaData;
|
|
|
+import java.sql.PreparedStatement;
|
|
|
+import java.sql.ResultSet;
|
|
|
+import java.sql.SQLException;
|
|
|
+import java.sql.Statement;
|
|
|
+import java.sql.Types;
|
|
|
+import java.util.ArrayList;
|
|
|
+import java.util.Arrays;
|
|
|
+import java.util.Collection;
|
|
|
+import java.util.Collections;
|
|
|
+import java.util.HashMap;
|
|
|
+import java.util.HashSet;
|
|
|
+import java.util.LinkedHashSet;
|
|
|
+import java.util.List;
|
|
|
+import java.util.Map;
|
|
|
+import java.util.Set;
|
|
|
+import java.util.concurrent.ConcurrentHashMap;
|
|
|
+import java.util.concurrent.CopyOnWriteArrayList;
|
|
|
+import java.util.logging.Level;
|
|
|
+import javax.sql.DataSource;
|
|
|
+import org.apache.commons.lang3.ArrayUtils;
|
|
|
+import org.geotools.data.DataStore;
|
|
|
+import org.geotools.data.DefaultTransaction;
|
|
|
+import org.geotools.data.FeatureStore;
|
|
|
+import org.geotools.data.GmlObjectStore;
|
|
|
+import org.geotools.data.InProcessLockingManager;
|
|
|
+import org.geotools.data.Query;
|
|
|
+import org.geotools.data.Transaction;
|
|
|
+import org.geotools.data.Transaction.State;
|
|
|
+import org.geotools.data.jdbc.FilterToSQL;
|
|
|
+import org.geotools.data.jdbc.FilterToSQLException;
|
|
|
+import org.geotools.data.jdbc.datasource.ManageableDataSource;
|
|
|
+import org.geotools.data.simple.SimpleFeatureCollection;
|
|
|
+import org.geotools.data.simple.SimpleFeatureIterator;
|
|
|
+import org.geotools.data.store.ContentDataStore;
|
|
|
+import org.geotools.data.store.ContentEntry;
|
|
|
+import org.geotools.data.store.ContentFeatureSource;
|
|
|
+import org.geotools.data.store.ContentState;
|
|
|
+import org.geotools.feature.AttributeTypeBuilder;
|
|
|
+import org.geotools.feature.NameImpl;
|
|
|
+import org.geotools.feature.simple.SimpleFeatureBuilder;
|
|
|
+import org.geotools.feature.visitor.CountVisitor;
|
|
|
+import org.geotools.feature.visitor.GroupByVisitor;
|
|
|
+import org.geotools.feature.visitor.LimitingVisitor;
|
|
|
+import org.geotools.feature.visitor.UniqueCountVisitor;
|
|
|
+import org.geotools.filter.FilterCapabilities;
|
|
|
+import org.geotools.geometry.jts.ReferencedEnvelope;
|
|
|
+import org.geotools.jdbc.JoinInfo.JoinPart;
|
|
|
+import org.geotools.referencing.CRS;
|
|
|
+import org.geotools.util.Converters;
|
|
|
+import org.geotools.util.SoftValueHashMap;
|
|
|
+import org.geotools.util.factory.Hints;
|
|
|
+import org.locationtech.jts.geom.Envelope;
|
|
|
+import org.locationtech.jts.geom.Geometry;
|
|
|
+import org.locationtech.jts.geom.Point;
|
|
|
+import org.opengis.feature.FeatureVisitor;
|
|
|
+import org.opengis.feature.simple.SimpleFeature;
|
|
|
+import org.opengis.feature.simple.SimpleFeatureType;
|
|
|
+import org.opengis.feature.type.AttributeDescriptor;
|
|
|
+import org.opengis.feature.type.GeometryDescriptor;
|
|
|
+import org.opengis.feature.type.Name;
|
|
|
+import org.opengis.filter.Filter;
|
|
|
+import org.opengis.filter.Id;
|
|
|
+import org.opengis.filter.PropertyIsLessThanOrEqualTo;
|
|
|
+import org.opengis.filter.expression.BinaryExpression;
|
|
|
+import org.opengis.filter.expression.Expression;
|
|
|
+import org.opengis.filter.expression.Function;
|
|
|
+import org.opengis.filter.expression.Literal;
|
|
|
+import org.opengis.filter.expression.PropertyName;
|
|
|
+import org.opengis.filter.identity.FeatureId;
|
|
|
+import org.opengis.filter.identity.GmlObjectId;
|
|
|
+import org.opengis.filter.sort.SortBy;
|
|
|
+import org.opengis.filter.sort.SortOrder;
|
|
|
+import org.opengis.referencing.FactoryException;
|
|
|
+import org.opengis.referencing.crs.CoordinateReferenceSystem;
|
|
|
+import org.opengis.referencing.operation.TransformException;
|
|
|
+
|
|
|
+/**
|
|
|
+ * Datastore implementation for jdbc based relational databases.
|
|
|
+ *
|
|
|
+ * <p>This class is not intended to be subclassed on a per database basis. Instead the notion of a
|
|
|
+ * "dialect" is used.
|
|
|
+ *
|
|
|
+ * <p>
|
|
|
+ *
|
|
|
+ * <h3>Dialects</h3>
|
|
|
+ *
|
|
|
+ * A dialect ({@link SQLDialect}) encapsulates all the operations that are database specific.
|
|
|
+ * Therefore to implement a jdbc based datastore one must extend SQLDialect. The specific dialect to
|
|
|
+ * use is set using {@link #setSQLDialect(SQLDialect)}.
|
|
|
+ *
|
|
|
+ * <p>
|
|
|
+ *
|
|
|
+ * <h3>Database Connections</h3>
|
|
|
+ *
|
|
|
+ * Connections to the underlying database are obtained through a {@link DataSource}. A datastore
|
|
|
+ * must be specified using {@link #setDataSource(DataSource)}.
|
|
|
+ *
|
|
|
+ * <p>
|
|
|
+ *
|
|
|
+ * <h3>Schemas</h3>
|
|
|
+ *
|
|
|
+ * This datastore supports the notion of database schemas, which is more or less just a grouping of
|
|
|
+ * tables. When a schema is specified, only those tables which are part of the schema are provided
|
|
|
+ * by the datastore. The schema is specified using {@link #setDatabaseSchema(String)}.
|
|
|
+ *
|
|
|
+ * <p>
|
|
|
+ *
|
|
|
+ * <h3>Spatial Functions</h3>
|
|
|
+ *
|
|
|
+ * The set of spatial operations or functions that are supported by the specific database are
|
|
|
+ * reported with a {@link FilterCapabilities} instance. This is specified using {@link
|
|
|
+ * #setFilterCapabilities(FilterCapabilities)}.
|
|
|
+ *
|
|
|
+ * @author Justin Deoliveira, The Open Planning Project
|
|
|
+ */
|
|
|
+public final class JDBCDataStore extends ContentDataStore implements GmlObjectStore {
|
|
|
+
|
|
|
+ /** Caches the "setValue" method in various aggregate visitors */
|
|
|
+ private static SoftValueHashMap<Class, Method> AGGREGATE_SETVALUE_CACHE =
|
|
|
+ new SoftValueHashMap<>(1000);
|
|
|
+
|
|
|
+ /**
|
|
|
+ * When true, record a stack trace documenting who disposed the JDBCDataStore. If dispose() is
|
|
|
+ * called a second time we can identify the offending parties.
|
|
|
+ */
|
|
|
+ protected static final Boolean TRACE_ENABLED =
|
|
|
+ "true".equalsIgnoreCase(System.getProperty("gt2.jdbc.trace"));
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The native SRID associated to a certain descriptor TODO: qualify this key with
|
|
|
+ * 'org.geotools.jdbc'
|
|
|
+ */
|
|
|
+ public static final String JDBC_NATIVE_SRID = "nativeSRID";
|
|
|
+
|
|
|
+ /** Boolean marker stating whether the feature type is to be considered read only */
|
|
|
+ public static final String JDBC_READ_ONLY = "org.geotools.jdbc.readOnly";
|
|
|
+
|
|
|
+ /** Boolean marker stating whether an attribute is part of the primary key */
|
|
|
+ public static final String JDBC_PRIMARY_KEY_COLUMN = "org.geotools.jdbc.pk.column";
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The key for attribute descriptor user data which specifies the original database column data
|
|
|
+ * type.
|
|
|
+ */
|
|
|
+ public static final String JDBC_NATIVE_TYPENAME = "org.geotools.jdbc.nativeTypeName";
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The key for attribute descriptor user data which specifies the original database column data
|
|
|
+ * type, as a {@link Types} value.
|
|
|
+ */
|
|
|
+ public static final String JDBC_NATIVE_TYPE = "org.geotools.jdbc.nativeType";
|
|
|
+
|
|
|
+ /** Used to specify the column alias to use when encoding a column in a select */
|
|
|
+ public static final String JDBC_COLUMN_ALIAS = "org.geotools.jdbc.columnAlias";
|
|
|
+
|
|
|
+ /** Contains a {@link EnumMapper} to support enums mapped from integer values */
|
|
|
+ public static final String JDBC_ENUM_MAP = "org.geotools.jdbc.enumMap";
|
|
|
+
|
|
|
+ /** name of table to use to store geometries when {@link #associations} is set. */
|
|
|
+ protected static final String GEOMETRY_TABLE = "geometry";
|
|
|
+
|
|
|
+ /**
|
|
|
+ * name of table to use to store multi geometries made up of non-multi geometries when {@link
|
|
|
+ * #associations} is set.
|
|
|
+ */
|
|
|
+ protected static final String MULTI_GEOMETRY_TABLE = "multi_geometry";
|
|
|
+
|
|
|
+ /** name of table to use to store geometry associations when {@link #associations} is set. */
|
|
|
+ protected static final String GEOMETRY_ASSOCIATION_TABLE = "geometry_associations";
|
|
|
+
|
|
|
+ /**
|
|
|
+ * name of table to use to store feature relationships (information about associations) when
|
|
|
+ * {@link #associations} is set.
|
|
|
+ */
|
|
|
+ protected static final String FEATURE_RELATIONSHIP_TABLE = "feature_relationships";
|
|
|
+
|
|
|
+ /** name of table to use to store feature associations when {@link #associations} is set. */
|
|
|
+ protected static final String FEATURE_ASSOCIATION_TABLE = "feature_associations";
|
|
|
+
|
|
|
+ /** The envelope returned when bounds is called against a geometryless feature type */
|
|
|
+ protected static final ReferencedEnvelope EMPTY_ENVELOPE = new ReferencedEnvelope();
|
|
|
+
|
|
|
+ /** Max number of ids to use for the optimized locks checking filter. */
|
|
|
+ public static final int MAX_IDS_IN_FILTER = 100;
|
|
|
+
|
|
|
+ /** data source */
|
|
|
+ protected DataSource dataSource;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Used with TRACE_ENABLED to record the thread responsible for disposing the JDBCDataStore. In
|
|
|
+ * the event dispose() is called a second time this throwable is used to identify the offending
|
|
|
+ * party.
|
|
|
+ */
|
|
|
+ private Throwable disposedBy = null;
|
|
|
+
|
|
|
+ /** the dialect of sql */
|
|
|
+ public SQLDialect dialect;
|
|
|
+
|
|
|
+ /** The database schema. */
|
|
|
+ protected String databaseSchema;
|
|
|
+
|
|
|
+ /** sql type to java class mappings */
|
|
|
+ protected HashMap<Integer, Class<?>> sqlTypeToClassMappings;
|
|
|
+
|
|
|
+ /** sql type name to java class mappings */
|
|
|
+ protected HashMap<String, Class<?>> sqlTypeNameToClassMappings;
|
|
|
+
|
|
|
+ /** java class to sql type mappings; */
|
|
|
+ protected HashMap<Class<?>, Integer> classToSqlTypeMappings;
|
|
|
+
|
|
|
+ /** sql type to sql type name overrides */
|
|
|
+ protected HashMap<Integer, String> sqlTypeToSqlTypeNameOverrides;
|
|
|
+
|
|
|
+ /** cache of sqltypes found in database */
|
|
|
+ protected ConcurrentHashMap<Integer, String> dBsqlTypesCache;
|
|
|
+
|
|
|
+ /** Feature visitor to aggregate function name */
|
|
|
+ protected HashMap<Class<? extends FeatureVisitor>, String> aggregateFunctions;
|
|
|
+
|
|
|
+ /** java supported filter function mappings to dialect name; */
|
|
|
+ protected HashMap<String, String> supportedFunctions;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * flag controlling if the datastore is supporting feature and geometry relationships with
|
|
|
+ * associations
|
|
|
+ */
|
|
|
+ protected boolean associations = false;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The fetch size for this datastore, defaulting to 1000. Set to a value less or equal to 0 to
|
|
|
+ * disable fetch size limit and grab all the records in one shot.
|
|
|
+ */
|
|
|
+ public int fetchSize;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The number of features to bufferize while inserting in order to do batch inserts.
|
|
|
+ *
|
|
|
+ * <p>By default 1 to avoid backward compatibility with badly written code that forgets to close
|
|
|
+ * the JDBCInsertFeatureWriter or does it after closing the DB connection.
|
|
|
+ */
|
|
|
+ protected int batchInsertSize = 1;
|
|
|
+
|
|
|
+ /** flag controlling whether primary key columns of a table are exposed via the feature type. */
|
|
|
+ protected boolean exposePrimaryKeyColumns = false;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Finds the primary key definitions (instantiated here because the finders might keep state)
|
|
|
+ */
|
|
|
+ protected PrimaryKeyFinder primaryKeyFinder =
|
|
|
+ new CompositePrimaryKeyFinder(
|
|
|
+ new MetadataTablePrimaryKeyFinder(), new HeuristicPrimaryKeyFinder());
|
|
|
+
|
|
|
+ /** Contains the SQL definition of the various virtual tables */
|
|
|
+ protected Map<String, VirtualTable> virtualTables = new ConcurrentHashMap<>();
|
|
|
+
|
|
|
+ /** The listeners that are allowed to handle the connection lifecycle */
|
|
|
+ protected List<ConnectionLifecycleListener> connectionLifecycleListeners =
|
|
|
+ new CopyOnWriteArrayList<>();
|
|
|
+
|
|
|
+ protected JDBCCallbackFactory callbackFactory = JDBCCallbackFactory.NULL;
|
|
|
+
|
|
|
+ private volatile NamePatternEscaping namePatternEscaping;
|
|
|
+
|
|
|
+ public JDBCDataStore() {
|
|
|
+ super();
|
|
|
+ }
|
|
|
+
|
|
|
+ public void setCallbackFactory(JDBCCallbackFactory factory) {
|
|
|
+ this.callbackFactory = factory;
|
|
|
+ }
|
|
|
+
|
|
|
+ public JDBCCallbackFactory getCallbackFactory() {
|
|
|
+ return callbackFactory;
|
|
|
+ }
|
|
|
+
|
|
|
+ public JDBCFeatureSource getAbsoluteFeatureSource(String typeName) throws IOException {
|
|
|
+ ContentFeatureSource featureSource = getFeatureSource(typeName);
|
|
|
+ if (featureSource instanceof JDBCFeatureSource) {
|
|
|
+ return (JDBCFeatureSource) featureSource;
|
|
|
+ }
|
|
|
+ return ((JDBCFeatureStore) featureSource).getFeatureSource();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Adds a virtual table to the data store. If a virtual table with the same name was registered
|
|
|
+ *
|
|
|
+ * @throws IOException If the view definition is not valid
|
|
|
+ */
|
|
|
+ public void createVirtualTable(VirtualTable vtable) throws IOException {
|
|
|
+ try {
|
|
|
+ virtualTables.put(vtable.getName(), new VirtualTable(vtable));
|
|
|
+ // the new vtable might be overriding a previous definition
|
|
|
+ entries.remove(new NameImpl(namespaceURI, vtable.getName()));
|
|
|
+ getSchema(vtable.getName());
|
|
|
+ } catch (IOException e) {
|
|
|
+ virtualTables.remove(vtable.getName());
|
|
|
+ throw e;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Returns a modifiable list of connection lifecycle listeners */
|
|
|
+ public List<ConnectionLifecycleListener> getConnectionLifecycleListeners() {
|
|
|
+ return connectionLifecycleListeners;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Removes and returns the specified virtual table */
|
|
|
+ public VirtualTable dropVirtualTable(String name) {
|
|
|
+ // the new vtable might be overriding a previous definition
|
|
|
+ VirtualTable vt = virtualTables.remove(name);
|
|
|
+ if (vt != null) {
|
|
|
+ entries.remove(new NameImpl(namespaceURI, name));
|
|
|
+ }
|
|
|
+ return vt;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Returns a live, immutable view of the virtual tables map (from name to definition) */
|
|
|
+ public Map<String, VirtualTable> getVirtualTables() {
|
|
|
+ Map<String, VirtualTable> result = new HashMap<>();
|
|
|
+ for (String key : virtualTables.keySet()) {
|
|
|
+ result.put(key, new VirtualTable(virtualTables.get(key)));
|
|
|
+ }
|
|
|
+ return Collections.unmodifiableMap(result);
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Returns the finder used to build {@link PrimaryKey} representations */
|
|
|
+ public PrimaryKeyFinder getPrimaryKeyFinder() {
|
|
|
+ return primaryKeyFinder;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Sets the finder used to build {@link PrimaryKey} representations */
|
|
|
+ public void setPrimaryKeyFinder(PrimaryKeyFinder primaryKeyFinder) {
|
|
|
+ this.primaryKeyFinder = primaryKeyFinder;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The current fetch size. The fetch size influences how many records are read from the dbms at
|
|
|
+ * a time. If set to a value less or equal than zero, all the records will be read in one shot,
|
|
|
+ * severily increasing the memory requirements to read a big number of features.
|
|
|
+ */
|
|
|
+ public int getFetchSize() {
|
|
|
+ return fetchSize;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Changes the fetch size. */
|
|
|
+ public void setFetchSize(int fetchSize) {
|
|
|
+ this.fetchSize = fetchSize;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** @return the number of features to bufferize while inserting in order to do batch inserts. */
|
|
|
+ public int getBatchInsertSize() {
|
|
|
+ return batchInsertSize;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Set the number of features to bufferize while inserting in order to do batch inserts.
|
|
|
+ *
|
|
|
+ * <p>Warning: when changing this value from its default of 1, the behavior of the {@link
|
|
|
+ * JDBCInsertFeatureWriter} is changed in non backward compatible ways. If your code closes the
|
|
|
+ * writer before closing the connection, you are fine. Plus, the feature added events will be
|
|
|
+ * delayed until a batch is actually inserted.
|
|
|
+ */
|
|
|
+ public void setBatchInsertSize(int batchInsertSize) {
|
|
|
+ this.batchInsertSize = batchInsertSize;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Determines if the datastore creates feature types which include those columns / attributes
|
|
|
+ * which compose the primary key.
|
|
|
+ */
|
|
|
+ public boolean isExposePrimaryKeyColumns() {
|
|
|
+ return exposePrimaryKeyColumns;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Sets the flag controlling if the datastore creates feature types which include those columns
|
|
|
+ * / attributes which compose the primary key.
|
|
|
+ */
|
|
|
+ public void setExposePrimaryKeyColumns(boolean exposePrimaryKeyColumns) {
|
|
|
+ if (this.exposePrimaryKeyColumns != exposePrimaryKeyColumns) {
|
|
|
+ entries.clear();
|
|
|
+ }
|
|
|
+ this.exposePrimaryKeyColumns = exposePrimaryKeyColumns;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The dialect the datastore uses to generate sql statements in order to communicate with the
|
|
|
+ * underlying database.
|
|
|
+ *
|
|
|
+ * @return The dialect, never <code>null</code>.
|
|
|
+ */
|
|
|
+ public SQLDialect getSQLDialect() {
|
|
|
+ return dialect;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Sets the dialect the datastore uses to generate sql statements in order to communicate with
|
|
|
+ * the underlying database.
|
|
|
+ *
|
|
|
+ * @param dialect The dialect, never <code>null</code>.
|
|
|
+ */
|
|
|
+ public void setSQLDialect(SQLDialect dialect) {
|
|
|
+ if (dialect == null) {
|
|
|
+ throw new NullPointerException();
|
|
|
+ }
|
|
|
+
|
|
|
+ this.dialect = dialect;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The data source the datastore uses to obtain connections to the underlying database.
|
|
|
+ *
|
|
|
+ * @return The data source, never <code>null</code>.
|
|
|
+ */
|
|
|
+ public DataSource getDataSource() {
|
|
|
+ if (dataSource == null) {
|
|
|
+ // Should never return null so throw an exception
|
|
|
+ if (TRACE_ENABLED) {
|
|
|
+ // If TRACE_ENABLED disposedBy may have stored an exception
|
|
|
+ if (disposedBy == null) {
|
|
|
+ LOGGER.log(Level.WARNING, "JDBCDataStore was never given a DataSource.");
|
|
|
+ throw new IllegalStateException(
|
|
|
+ "DataSource not available as it was never set.");
|
|
|
+ } else {
|
|
|
+ LOGGER.log(
|
|
|
+ Level.WARNING, "JDBCDataStore was disposed:" + disposedBy, disposedBy);
|
|
|
+ throw new IllegalStateException(
|
|
|
+ "DataSource not available after calling dispose().");
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ throw new IllegalStateException(
|
|
|
+ "DataSource not available after calling dispose() or before being set.");
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return dataSource;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Sets the data source the datastore uses to obtain connections to the underlying database.
|
|
|
+ *
|
|
|
+ * @param dataSource The data source, never <code>null</code>.
|
|
|
+ */
|
|
|
+ public void setDataSource(DataSource dataSource) {
|
|
|
+ if (this.dataSource != null) {
|
|
|
+ LOGGER.log(
|
|
|
+ Level.FINE,
|
|
|
+ "Setting DataSource on JDBCDataStore that already has DataSource set");
|
|
|
+ }
|
|
|
+ if (dataSource == null) {
|
|
|
+ throw new IllegalArgumentException(
|
|
|
+ "JDBCDataStore's DataSource should not be set to null");
|
|
|
+ }
|
|
|
+ this.dataSource = dataSource;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The schema from which this datastore is serving tables from.
|
|
|
+ *
|
|
|
+ * @return the schema, or <code>null</code> if non specified.
|
|
|
+ */
|
|
|
+ public String getDatabaseSchema() {
|
|
|
+ return databaseSchema;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Set the database schema for the datastore.
|
|
|
+ *
|
|
|
+ * <p>When this value is set only those tables which are part of the schema are served through
|
|
|
+ * the datastore. This value can be set to <code>null</code> to specify no particular schema.
|
|
|
+ *
|
|
|
+ * @param databaseSchema The schema, may be <code>null</code>.
|
|
|
+ */
|
|
|
+ public void setDatabaseSchema(String databaseSchema) {
|
|
|
+ this.databaseSchema = databaseSchema;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The filter capabilities which reports which spatial operations the underlying database can
|
|
|
+ * handle natively.
|
|
|
+ *
|
|
|
+ * @return The filter capabilities, never <code>null</code>.
|
|
|
+ */
|
|
|
+ public FilterCapabilities getFilterCapabilities() {
|
|
|
+ if (dialect instanceof PreparedStatementSQLDialect)
|
|
|
+ return ((PreparedStatementSQLDialect) dialect)
|
|
|
+ .createPreparedFilterToSQL()
|
|
|
+ .getCapabilities();
|
|
|
+ else return ((BasicSQLDialect) dialect).createFilterToSQL().getCapabilities();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Flag controlling if the datastore is supporting feature and geometry relationships with
|
|
|
+ * associations
|
|
|
+ */
|
|
|
+ public boolean isAssociations() {
|
|
|
+ return associations;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Sets the flag controlling if the datastore is supporting feature and geometry relationships
|
|
|
+ * with associations
|
|
|
+ */
|
|
|
+ public void setAssociations(boolean foreignKeyGeometries) {
|
|
|
+ this.associations = foreignKeyGeometries;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The sql type to java type mappings that the datastore uses when reading and writing objects
|
|
|
+ * to and from the database.
|
|
|
+ *
|
|
|
+ * <p>These mappings are derived from {@link
|
|
|
+ * SQLDialect#registerSqlTypeToClassMappings(Map)}
|
|
|
+ *
|
|
|
+ * @return The mappings, never <code>null</code>.
|
|
|
+ */
|
|
|
+ public Map<Integer, Class<?>> getSqlTypeToClassMappings() {
|
|
|
+ if (sqlTypeToClassMappings == null) {
|
|
|
+ sqlTypeToClassMappings = new HashMap<>();
|
|
|
+ dialect.registerSqlTypeToClassMappings(sqlTypeToClassMappings);
|
|
|
+ }
|
|
|
+
|
|
|
+ return sqlTypeToClassMappings;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The sql type name to java type mappings that the dialect uses when
|
|
|
+ * reading and writing objects to and from the database.
|
|
|
+ * <p>
|
|
|
+ * These mappings are derived from {@link SQLDialect#registerSqlTypeNameToClassMappings(Map)}
|
|
|
+ * </p>
|
|
|
+ *
|
|
|
+ * @return The mappings, never <code>null<code>.
|
|
|
+ */
|
|
|
+ public Map<String, Class<?>> getSqlTypeNameToClassMappings() {
|
|
|
+ if (sqlTypeNameToClassMappings == null) {
|
|
|
+ sqlTypeNameToClassMappings = new HashMap<>();
|
|
|
+ dialect.registerSqlTypeNameToClassMappings(sqlTypeNameToClassMappings);
|
|
|
+ }
|
|
|
+
|
|
|
+ return sqlTypeNameToClassMappings;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The java type to sql type mappings that the datastore uses when reading and writing objects
|
|
|
+ * to and from the database.
|
|
|
+ *
|
|
|
+ * <p>These mappings are derived from {@link SQLDialect#registerClassToSqlMappings(Map)}
|
|
|
+ *
|
|
|
+ * @return The mappings, never <code>null</code>.
|
|
|
+ */
|
|
|
+ public Map<Class<?>, Integer> getClassToSqlTypeMappings() {
|
|
|
+ if (classToSqlTypeMappings == null) {
|
|
|
+ HashMap<Class<?>, Integer> classToSqlTypeMappings = new HashMap<>();
|
|
|
+ dialect.registerClassToSqlMappings(classToSqlTypeMappings);
|
|
|
+ this.classToSqlTypeMappings = classToSqlTypeMappings;
|
|
|
+ }
|
|
|
+ return classToSqlTypeMappings;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns any ovverides which map integer constants for database types (from {@link Types}) to
|
|
|
+ * database type names.
|
|
|
+ *
|
|
|
+ * <p>This method will return an empty map when there are no overrides.
|
|
|
+ */
|
|
|
+ public Map<Integer, String> getSqlTypeToSqlTypeNameOverrides() {
|
|
|
+ if (sqlTypeToSqlTypeNameOverrides == null) {
|
|
|
+ sqlTypeToSqlTypeNameOverrides = new HashMap<>();
|
|
|
+ dialect.registerSqlTypeToSqlTypeNameOverrides(sqlTypeToSqlTypeNameOverrides);
|
|
|
+ }
|
|
|
+
|
|
|
+ return sqlTypeToSqlTypeNameOverrides;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns a map integer constants for database types (from {@link Types}) to database type
|
|
|
+ * names.
|
|
|
+ *
|
|
|
+ * <p>This method will return an empty map when there are no overrides.
|
|
|
+ */
|
|
|
+ public ConcurrentHashMap<Integer, String> getDBsqlTypesCache() {
|
|
|
+ if (dBsqlTypesCache == null) {
|
|
|
+ dBsqlTypesCache = new ConcurrentHashMap<>();
|
|
|
+ }
|
|
|
+
|
|
|
+ return dBsqlTypesCache;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Returns the supported aggregate functions and the visitors they map to. */
|
|
|
+ public Map<Class<? extends FeatureVisitor>, String> getAggregateFunctions() {
|
|
|
+ if (aggregateFunctions == null) {
|
|
|
+ aggregateFunctions = new HashMap<>();
|
|
|
+ dialect.registerAggregateFunctions(aggregateFunctions);
|
|
|
+ }
|
|
|
+ return aggregateFunctions;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the java type mapped to the specified sql type.
|
|
|
+ *
|
|
|
+ * <p>If there is no such type mapped to <tt>sqlType</tt>, <code>null</code> is returned.
|
|
|
+ *
|
|
|
+ * @param sqlType The integer constant for the sql type from {@link Types}.
|
|
|
+ * @return The mapped java class, or <code>null</code>. if no such mapping exists.
|
|
|
+ */
|
|
|
+ public Class<?> getMapping(int sqlType) {
|
|
|
+ return getSqlTypeToClassMappings().get(Integer.valueOf(sqlType));
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the java type mapped to the specified sql type name.
|
|
|
+ *
|
|
|
+ * <p>If there is no such type mapped to <tt>sqlTypeName</tt>, <code>null</code> is returned.
|
|
|
+ *
|
|
|
+ * @param sqlTypeName The name of the sql type.
|
|
|
+ * @return The mapped java class, or <code>null</code>. if no such mapping exists.
|
|
|
+ */
|
|
|
+ public Class<?> getMapping(String sqlTypeName) {
|
|
|
+ return getSqlTypeNameToClassMappings().get(sqlTypeName);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the sql type mapped to the specified java type.
|
|
|
+ *
|
|
|
+ * <p>If there is no such type mapped to <tt>clazz</tt>, <code>Types.OTHER</code> is returned.
|
|
|
+ *
|
|
|
+ * @param clazz The java class.
|
|
|
+ * @return The mapped sql type from {@link Types}, Types.OTHER if no such mapping exists.
|
|
|
+ */
|
|
|
+ public Integer getMapping(Class<?> clazz) {
|
|
|
+ Integer mapping = getClassToSqlTypeMappings().get(clazz);
|
|
|
+
|
|
|
+ // check for arrays, but don't get fooled by BLOB/CLOB java counterparts
|
|
|
+ if (mapping == null && clazz.isArray()) {
|
|
|
+ mapping = Types.ARRAY;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (mapping == null) {
|
|
|
+ // no match, try a "fuzzy" match in which we find the super class which matches best
|
|
|
+ List<Map.Entry<Class<?>, Integer>> matches = new ArrayList<>();
|
|
|
+ for (Map.Entry<Class<?>, Integer> e : getClassToSqlTypeMappings().entrySet()) {
|
|
|
+ if (e.getKey().isAssignableFrom(clazz)) {
|
|
|
+ matches.add(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!matches.isEmpty()) {
|
|
|
+ if (matches.size() == 1) {
|
|
|
+ // single match, great, use it
|
|
|
+ mapping = matches.get(0).getValue();
|
|
|
+ } else {
|
|
|
+ // sort to match lowest class in type hierarchy, if we end up with a list like:
|
|
|
+ // A, B where B is a super class of A, then chose A since it is the closest
|
|
|
+ // subclass to match
|
|
|
+
|
|
|
+ Collections.sort(
|
|
|
+ matches,
|
|
|
+ (o1, o2) -> {
|
|
|
+ if (o1.getKey().isAssignableFrom(o2.getKey())) {
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ if (o2.getKey().isAssignableFrom(o1.getKey())) {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+ });
|
|
|
+ if (matches.get(1).getKey().isAssignableFrom(matches.get(0).getKey())) {
|
|
|
+ mapping = matches.get(0).getValue();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (mapping == null) {
|
|
|
+ mapping = Types.OTHER;
|
|
|
+ LOGGER.warning("No mapping for " + clazz.getName());
|
|
|
+ }
|
|
|
+
|
|
|
+ return mapping;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates a table in the underlying database from the specified table.
|
|
|
+ *
|
|
|
+ * <p>This method will map the classes of the attributes of <tt>featureType</tt> to sql types
|
|
|
+ * and generate a 'CREATE TABLE' statement against the underlying database.
|
|
|
+ *
|
|
|
+ * @see DataStore#createSchema(SimpleFeatureType)
|
|
|
+ * @throws IllegalArgumentException If the table already exists.
|
|
|
+ * @throws IOException If the table cannot be created due to an error.
|
|
|
+ */
|
|
|
+ @Override
|
|
|
+ public void createSchema(final SimpleFeatureType featureType) throws IOException {
|
|
|
+ if (entry(featureType.getName()) != null) {
|
|
|
+ String msg = "Schema '" + featureType.getName() + "' already exists";
|
|
|
+ throw new IllegalArgumentException(msg);
|
|
|
+ }
|
|
|
+
|
|
|
+ // execute the create table statement
|
|
|
+ // TODO: create a primary key and a spatial index
|
|
|
+ Connection cx = createConnection();
|
|
|
+
|
|
|
+ try {
|
|
|
+ String sql = createTableSQL(featureType, cx);
|
|
|
+ LOGGER.log(Level.FINE, "Create schema: {0}", sql);
|
|
|
+
|
|
|
+ Statement st = cx.createStatement();
|
|
|
+
|
|
|
+ try {
|
|
|
+ st.execute(sql);
|
|
|
+ } finally {
|
|
|
+ closeSafe(st);
|
|
|
+ }
|
|
|
+
|
|
|
+ dialect.postCreateTable(databaseSchema, featureType, cx);
|
|
|
+ } catch (Exception e) {
|
|
|
+ String msg = "Error occurred creating table";
|
|
|
+ throw (IOException) new IOException(msg).initCause(e);
|
|
|
+ } finally {
|
|
|
+ closeSafe(cx);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ @Override
|
|
|
+ public void removeSchema(String typeName) throws IOException {
|
|
|
+ removeSchema(name(typeName));
|
|
|
+ }
|
|
|
+
|
|
|
+ @Override
|
|
|
+ public void removeSchema(Name typeName) throws IOException {
|
|
|
+ if (entry(typeName) == null) {
|
|
|
+ String msg = "Schema '" + typeName + "' does not exist";
|
|
|
+ throw new IllegalArgumentException(msg);
|
|
|
+ }
|
|
|
+
|
|
|
+ // check for virtual table
|
|
|
+ if (virtualTables.containsKey(typeName.getLocalPart())) {
|
|
|
+ dropVirtualTable(typeName.getLocalPart());
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ SimpleFeatureType featureType = getSchema(typeName);
|
|
|
+
|
|
|
+ // execute the drop table statement
|
|
|
+ Connection cx = createConnection();
|
|
|
+ try {
|
|
|
+ // give the dialect a chance to cleanup pre
|
|
|
+ dialect.preDropTable(databaseSchema, featureType, cx);
|
|
|
+
|
|
|
+ String sql = dropTableSQL(featureType, cx);
|
|
|
+ LOGGER.log(Level.FINE, "Drop schema: {0}", sql);
|
|
|
+
|
|
|
+ Statement st = cx.createStatement();
|
|
|
+
|
|
|
+ try {
|
|
|
+ st.execute(sql);
|
|
|
+ } finally {
|
|
|
+ closeSafe(st);
|
|
|
+ }
|
|
|
+
|
|
|
+ dialect.postDropTable(databaseSchema, featureType, cx);
|
|
|
+ removeEntry(typeName);
|
|
|
+ } catch (Exception e) {
|
|
|
+ String msg = "Error occurred dropping table";
|
|
|
+ throw (IOException) new IOException(msg).initCause(e);
|
|
|
+ } finally {
|
|
|
+ closeSafe(cx);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /** */
|
|
|
+ @Override
|
|
|
+ public Object getGmlObject(GmlObjectId id, Hints hints) throws IOException {
|
|
|
+ // geometry?
|
|
|
+ if (isAssociations()) {
|
|
|
+
|
|
|
+ Connection cx = createConnection();
|
|
|
+ try {
|
|
|
+ try {
|
|
|
+ Statement st = null;
|
|
|
+ ResultSet rs = null;
|
|
|
+
|
|
|
+ if (getSQLDialect() instanceof PreparedStatementSQLDialect) {
|
|
|
+ st = selectGeometrySQLPS(id.getID(), cx);
|
|
|
+ rs = ((PreparedStatement) st).executeQuery();
|
|
|
+ } else {
|
|
|
+ String sql = selectGeometrySQL(id.getID());
|
|
|
+ LOGGER.log(Level.FINE, "Get GML object: {0}", sql);
|
|
|
+
|
|
|
+ st = cx.createStatement();
|
|
|
+ rs = st.executeQuery(sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ try {
|
|
|
+ if (rs.next()) {
|
|
|
+ // read the geometry
|
|
|
+ Geometry g =
|
|
|
+ getSQLDialect()
|
|
|
+ .decodeGeometryValue(
|
|
|
+ null,
|
|
|
+ rs,
|
|
|
+ "geometry",
|
|
|
+ getGeometryFactory(),
|
|
|
+ cx,
|
|
|
+ hints);
|
|
|
+
|
|
|
+ // read the metadata
|
|
|
+ String name = rs.getString("name");
|
|
|
+ String desc = rs.getString("description");
|
|
|
+ setGmlProperties(g, id.getID(), name, desc);
|
|
|
+
|
|
|
+ return g;
|
|
|
+ }
|
|
|
+ } finally {
|
|
|
+ closeSafe(rs);
|
|
|
+ closeSafe(st);
|
|
|
+ }
|
|
|
+
|
|
|
+ } catch (SQLException e) {
|
|
|
+ throw (IOException) new IOException().initCause(e);
|
|
|
+ }
|
|
|
+ } finally {
|
|
|
+ closeSafe(cx);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // regular feature, first feature out the feature type
|
|
|
+ int i = id.getID().indexOf('.');
|
|
|
+ if (i == -1) {
|
|
|
+ LOGGER.info("Unable to determine feature type for GmlObjectId:" + id);
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ // figure out the type name from the id
|
|
|
+ String featureTypeName = id.getID().substring(0, i);
|
|
|
+ SimpleFeatureType featureType = getSchema(featureTypeName);
|
|
|
+ if (featureType == null) {
|
|
|
+ throw new IllegalArgumentException("No such feature type: " + featureTypeName);
|
|
|
+ }
|
|
|
+
|
|
|
+ // load the feature
|
|
|
+ Id filter = getFilterFactory().id(Collections.singleton(id));
|
|
|
+ Query query = new Query(featureTypeName);
|
|
|
+ query.setFilter(filter);
|
|
|
+ query.setHints(hints);
|
|
|
+
|
|
|
+ SimpleFeatureCollection features = getFeatureSource(featureTypeName).getFeatures(query);
|
|
|
+ if (!features.isEmpty()) {
|
|
|
+ try (SimpleFeatureIterator fi = features.features()) {
|
|
|
+ if (fi.hasNext()) {
|
|
|
+ return fi.next();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates a new instance of {@link JDBCFeatureStore}.
|
|
|
+ *
|
|
|
+ * @see ContentDataStore#createFeatureSource(ContentEntry)
|
|
|
+ */
|
|
|
+ @Override
|
|
|
+ protected ContentFeatureSource createFeatureSource(ContentEntry entry) throws IOException {
|
|
|
+ // grab the schema, it carries a flag telling us if the feature type is read only
|
|
|
+ SimpleFeatureType schema = entry.getState(Transaction.AUTO_COMMIT).getFeatureType();
|
|
|
+ if (schema == null) {
|
|
|
+ // if the schema still haven't been computed, force its computation so
|
|
|
+ // that we can decide if the feature type is read only
|
|
|
+ schema = new JDBCFeatureSource(entry, null).buildFeatureType();
|
|
|
+ entry.getState(Transaction.AUTO_COMMIT).setFeatureType(schema);
|
|
|
+ }
|
|
|
+
|
|
|
+ Object readOnlyMarker = schema.getUserData().get(JDBC_READ_ONLY);
|
|
|
+ if (Boolean.TRUE.equals(readOnlyMarker)) {
|
|
|
+ return new JDBCFeatureSource(entry, null);
|
|
|
+ }
|
|
|
+ return new JDBCFeatureStore(entry, null);
|
|
|
+ }
|
|
|
+
|
|
|
+ // /**
|
|
|
+ // * Creates a new instance of {@link JDBCTransactionState}.
|
|
|
+ // */
|
|
|
+ // protected State createTransactionState(ContentSimpleFeatureSource featureSource)
|
|
|
+ // throws IOException {
|
|
|
+ // return new JDBCTransactionState((JDBCFeatureStore) featureSource);
|
|
|
+ // }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates an instanceof {@link JDBCState}.
|
|
|
+ *
|
|
|
+ * @see ContentDataStore#createContentState(ContentEntry)
|
|
|
+ */
|
|
|
+ @Override
|
|
|
+ protected ContentState createContentState(ContentEntry entry) {
|
|
|
+ JDBCState state = new JDBCState(entry);
|
|
|
+ state.setExposePrimaryKeyColumns(exposePrimaryKeyColumns);
|
|
|
+ return state;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Generates the list of type names provided by the database.
|
|
|
+ *
|
|
|
+ * <p>The list is generated from the underlying database metadata.
|
|
|
+ */
|
|
|
+ @Override
|
|
|
+ protected List<Name> createTypeNames() throws IOException {
|
|
|
+ Connection cx = createConnection();
|
|
|
+
|
|
|
+ /*
|
|
|
+ * <LI><B>TABLE_CAT</B> String => table catalog (may be <code>null</code>)
|
|
|
+ * <LI><B>TABLE_SCHEM</B> String => table schema (may be <code>null</code>)
|
|
|
+ * <LI><B>TABLE_NAME</B> String => table name
|
|
|
+ * <LI><B>TABLE_TYPE</B> String => table type. Typical types are "TABLE",
|
|
|
+ * "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY",
|
|
|
+ * "LOCAL TEMPORARY", "ALIAS", "SYNONYM".
|
|
|
+ * <LI><B>REMARKS</B> String => explanatory comment on the table
|
|
|
+ * <LI><B>TYPE_CAT</B> String => the types catalog (may be <code>null</code>)
|
|
|
+ * <LI><B>TYPE_SCHEM</B> String => the types schema (may be <code>null</code>)
|
|
|
+ * <LI><B>TYPE_NAME</B> String => type name (may be <code>null</code>)
|
|
|
+ * <LI><B>SELF_REFERENCING_COL_NAME</B> String => name of the designated
|
|
|
+ * "identifier" column of a typed table (may be <code>null</code>)
|
|
|
+ * <LI><B>REF_GENERATION</B> String => specifies how values in
|
|
|
+ * SELF_REFERENCING_COL_NAME are created. Values are
|
|
|
+ * "SYSTEM", "USER", "DERIVED". (may be <code>null</code>)
|
|
|
+ */
|
|
|
+ List<Name> typeNames = new ArrayList<>();
|
|
|
+
|
|
|
+ try {
|
|
|
+ DatabaseMetaData metaData = cx.getMetaData();
|
|
|
+ Set<String> availableTableTypes = new HashSet<>();
|
|
|
+
|
|
|
+ ResultSet tableTypes = null;
|
|
|
+ try {
|
|
|
+ tableTypes = metaData.getTableTypes();
|
|
|
+ while (tableTypes.next()) {
|
|
|
+ availableTableTypes.add(tableTypes.getString("TABLE_TYPE"));
|
|
|
+ }
|
|
|
+ } finally {
|
|
|
+ closeSafe(tableTypes);
|
|
|
+ }
|
|
|
+ Set<String> queryTypes = new HashSet<>();
|
|
|
+ for (String desiredTableType : dialect.getDesiredTablesType()) {
|
|
|
+ if (availableTableTypes.contains(desiredTableType)) {
|
|
|
+ queryTypes.add(desiredTableType);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ResultSet tables =
|
|
|
+ metaData.getTables(
|
|
|
+ null,
|
|
|
+ escapeNamePattern(metaData, databaseSchema),
|
|
|
+ "%",
|
|
|
+ queryTypes.toArray(new String[0]));
|
|
|
+ try {
|
|
|
+ if (fetchSize > 1) {
|
|
|
+ tables.setFetchSize(fetchSize);
|
|
|
+ }
|
|
|
+ while (tables.next()) {
|
|
|
+ String schemaName = tables.getString("TABLE_SCHEM");
|
|
|
+ String tableName = tables.getString("TABLE_NAME");
|
|
|
+
|
|
|
+ // use the dialect to filter
|
|
|
+ if (!dialect.includeTable(schemaName, tableName, cx)) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ typeNames.add(new NameImpl(namespaceURI, tableName));
|
|
|
+ }
|
|
|
+ } finally {
|
|
|
+ closeSafe(tables);
|
|
|
+ }
|
|
|
+ } catch (SQLException e) {
|
|
|
+ throw (IOException)
|
|
|
+ new IOException("Error occurred getting table name list.").initCause(e);
|
|
|
+ } finally {
|
|
|
+ closeSafe(cx);
|
|
|
+ }
|
|
|
+
|
|
|
+ for (String virtualTable : virtualTables.keySet()) {
|
|
|
+ typeNames.add(new NameImpl(namespaceURI, virtualTable));
|
|
|
+ }
|
|
|
+ return typeNames;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the primary key object for a particular entry, deriving it from the underlying
|
|
|
+ * database metadata.
|
|
|
+ */
|
|
|
+ protected PrimaryKey getPrimaryKey(ContentEntry entry) throws IOException {
|
|
|
+ JDBCState state = (JDBCState) entry.getState(Transaction.AUTO_COMMIT);
|
|
|
+
|
|
|
+ if (state.getPrimaryKey() == null) {
|
|
|
+ synchronized (this) {
|
|
|
+ if (state.getPrimaryKey() == null) {
|
|
|
+ // get metadata from database
|
|
|
+ Connection cx = createConnection();
|
|
|
+
|
|
|
+ try {
|
|
|
+ PrimaryKey pkey = null;
|
|
|
+ String tableName = entry.getName().getLocalPart();
|
|
|
+ if (virtualTables.containsKey(tableName)) {
|
|
|
+ VirtualTable vt = virtualTables.get(tableName);
|
|
|
+ if (vt.getPrimaryKeyColumns().size() == 0) {
|
|
|
+ pkey = new NullPrimaryKey(tableName);
|
|
|
+ } else {
|
|
|
+ List<ColumnMetadata> metas =
|
|
|
+ JDBCFeatureSource.getColumnMetadata(cx, vt, dialect, this);
|
|
|
+
|
|
|
+ List<PrimaryKeyColumn> kcols = new ArrayList<>();
|
|
|
+ for (String pkName : vt.getPrimaryKeyColumns()) {
|
|
|
+ // look for the pk type
|
|
|
+ Class binding = null;
|
|
|
+ for (ColumnMetadata meta : metas) {
|
|
|
+ if (meta.name.equals(pkName)) {
|
|
|
+ binding = meta.binding;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // we build a pk without type, the JDBCFeatureStore will do this
|
|
|
+ // for us while building the primary key
|
|
|
+ kcols.add(new NonIncrementingPrimaryKeyColumn(pkName, binding));
|
|
|
+ }
|
|
|
+ pkey = new PrimaryKey(tableName, kcols);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ try {
|
|
|
+ pkey =
|
|
|
+ primaryKeyFinder.getPrimaryKey(
|
|
|
+ this, databaseSchema, tableName, cx);
|
|
|
+ } catch (SQLException e) {
|
|
|
+ LOGGER.log(
|
|
|
+ Level.WARNING,
|
|
|
+ "Failure occurred while looking up the primary key with "
|
|
|
+ + "finder: "
|
|
|
+ + primaryKeyFinder,
|
|
|
+ e);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (pkey == null) {
|
|
|
+ String msg =
|
|
|
+ "No primary key or unique index found for "
|
|
|
+ + tableName
|
|
|
+ + ".";
|
|
|
+ LOGGER.info(msg);
|
|
|
+
|
|
|
+ pkey = new NullPrimaryKey(tableName);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ state.setPrimaryKey(pkey);
|
|
|
+ } catch (SQLException e) {
|
|
|
+ String msg = "Error looking up primary key";
|
|
|
+ throw (IOException) new IOException(msg).initCause(e);
|
|
|
+ } finally {
|
|
|
+ closeSafe(cx);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return state.getPrimaryKey();
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Checks whether the tableName corresponds to a view */
|
|
|
+ boolean isView(DatabaseMetaData metaData, String databaseSchema, String tableName)
|
|
|
+ throws SQLException {
|
|
|
+
|
|
|
+ ResultSet tables = null;
|
|
|
+ try {
|
|
|
+ tables =
|
|
|
+ metaData.getTables(
|
|
|
+ null,
|
|
|
+ escapeNamePattern(metaData, databaseSchema),
|
|
|
+ escapeNamePattern(metaData, tableName),
|
|
|
+ new String[] {"VIEW"});
|
|
|
+ return tables.next();
|
|
|
+ } finally {
|
|
|
+ closeSafe(tables);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /*
|
|
|
+ * Creates a key from a primary key or unique index.
|
|
|
+ */
|
|
|
+ PrimaryKey createPrimaryKey(
|
|
|
+ ResultSet index, DatabaseMetaData metaData, String tableName, Connection cx)
|
|
|
+ throws SQLException {
|
|
|
+ ArrayList<PrimaryKeyColumn> cols = new ArrayList<>();
|
|
|
+
|
|
|
+ while (index.next()) {
|
|
|
+ String columnName = index.getString("COLUMN_NAME");
|
|
|
+ // work around. For some reason the first record returned is always 'empty'
|
|
|
+ // this was tested on Oracle and Postgres databases
|
|
|
+ if (columnName == null) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // look up the type ( should only be one row )
|
|
|
+ Class columnType = getColumnType(metaData, databaseSchema, tableName, columnName);
|
|
|
+
|
|
|
+ // determine which type of primary key we have
|
|
|
+ PrimaryKeyColumn col = null;
|
|
|
+
|
|
|
+ // 1. Auto Incrementing?
|
|
|
+ Statement st = cx.createStatement();
|
|
|
+
|
|
|
+ try {
|
|
|
+ // not actually going to get data
|
|
|
+ st.setFetchSize(1);
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("SELECT ");
|
|
|
+ dialect.encodeColumnName(null, columnName, sql);
|
|
|
+ sql.append(" FROM ");
|
|
|
+ encodeTableName(tableName, sql, null);
|
|
|
+
|
|
|
+ sql.append(" WHERE 0=1");
|
|
|
+
|
|
|
+ LOGGER.log(Level.FINE, "Grabbing table pk metadata: {0}", sql);
|
|
|
+
|
|
|
+ ResultSet rs = st.executeQuery(sql.toString());
|
|
|
+
|
|
|
+ try {
|
|
|
+ if (rs.getMetaData().isAutoIncrement(1)) {
|
|
|
+ col = new AutoGeneratedPrimaryKeyColumn(columnName, columnType);
|
|
|
+ }
|
|
|
+ } finally {
|
|
|
+ closeSafe(rs);
|
|
|
+ }
|
|
|
+ } finally {
|
|
|
+ closeSafe(st);
|
|
|
+ }
|
|
|
+
|
|
|
+ // 2. Has a sequence?
|
|
|
+ if (col == null) {
|
|
|
+ try {
|
|
|
+ String sequenceName =
|
|
|
+ dialect.getSequenceForColumn(databaseSchema, tableName, columnName, cx);
|
|
|
+ if (sequenceName != null) {
|
|
|
+ col = new SequencedPrimaryKeyColumn(columnName, columnType, sequenceName);
|
|
|
+ }
|
|
|
+ } catch (Exception e) {
|
|
|
+ // log the exception , and continue on
|
|
|
+ LOGGER.log(
|
|
|
+ Level.WARNING,
|
|
|
+ "Error occured determining sequence for "
|
|
|
+ + columnName
|
|
|
+ + ", "
|
|
|
+ + tableName,
|
|
|
+ e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (col == null) {
|
|
|
+ col = new NonIncrementingPrimaryKeyColumn(columnName, columnType);
|
|
|
+ }
|
|
|
+
|
|
|
+ cols.add(col);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!cols.isEmpty()) {
|
|
|
+ return new PrimaryKey(tableName, cols);
|
|
|
+ }
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the type of the column by inspecting the metadata, with the collaboration of the
|
|
|
+ * dialect
|
|
|
+ */
|
|
|
+ protected Class getColumnType(
|
|
|
+ DatabaseMetaData metaData, String databaseSchema2, String tableName, String columnName)
|
|
|
+ throws SQLException {
|
|
|
+ ResultSet columns = null;
|
|
|
+ try {
|
|
|
+ columns =
|
|
|
+ metaData.getColumns(
|
|
|
+ null,
|
|
|
+ escapeNamePattern(metaData, databaseSchema),
|
|
|
+ escapeNamePattern(metaData, tableName),
|
|
|
+ escapeNamePattern(metaData, columnName));
|
|
|
+ if (!columns.next()) {
|
|
|
+ throw new SQLException("Could not find metadata for column");
|
|
|
+ }
|
|
|
+
|
|
|
+ int binding = columns.getInt("DATA_TYPE");
|
|
|
+ Class columnType = getMapping(binding);
|
|
|
+
|
|
|
+ if (columnType == null) {
|
|
|
+ LOGGER.warning("No class for sql type " + binding);
|
|
|
+ columnType = Object.class;
|
|
|
+ }
|
|
|
+
|
|
|
+ return columnType;
|
|
|
+ } finally {
|
|
|
+ closeSafe(columns);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the primary key object for a particular feature type / table, deriving it from the
|
|
|
+ * underlying database metadata.
|
|
|
+ */
|
|
|
+ public PrimaryKey getPrimaryKey(SimpleFeatureType featureType) throws IOException {
|
|
|
+ return getPrimaryKey(ensureEntry(featureType.getName()));
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Returns the expose primary key columns flag for the specified feature type */
|
|
|
+ protected boolean isExposePrimaryKeyColumns(SimpleFeatureType featureType) throws IOException {
|
|
|
+ ContentEntry entry = ensureEntry(featureType.getName());
|
|
|
+ JDBCState state = (JDBCState) entry.getState(Transaction.AUTO_COMMIT);
|
|
|
+ return state.isExposePrimaryKeyColumns();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the bounds of the features for a particular feature type / table.
|
|
|
+ *
|
|
|
+ * @param featureType The feature type / table.
|
|
|
+ * @param query Specifies rows to include in bounds calculation, as well as how many features
|
|
|
+ * and the offset if needed
|
|
|
+ */
|
|
|
+ protected ReferencedEnvelope getBounds(
|
|
|
+ SimpleFeatureType featureType, Query query, Connection cx) throws IOException {
|
|
|
+
|
|
|
+ // handle geometryless case by returning an emtpy envelope
|
|
|
+ if (featureType.getGeometryDescriptor() == null) return EMPTY_ENVELOPE;
|
|
|
+
|
|
|
+ Statement st = null;
|
|
|
+ ResultSet rs = null;
|
|
|
+ ReferencedEnvelope bounds =
|
|
|
+ ReferencedEnvelope.create(featureType.getCoordinateReferenceSystem());
|
|
|
+ try {
|
|
|
+ // try optimized bounds computation only if we're targeting the entire table
|
|
|
+ if (isFullBoundsQuery(query, featureType)) {
|
|
|
+ List<ReferencedEnvelope> result =
|
|
|
+ dialect.getOptimizedBounds(databaseSchema, featureType, cx);
|
|
|
+ if (result != null && !result.isEmpty()) {
|
|
|
+ // merge the envelopes into one
|
|
|
+ for (ReferencedEnvelope envelope : result) {
|
|
|
+ bounds = mergeEnvelope(bounds, envelope);
|
|
|
+ }
|
|
|
+ return bounds;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // build an aggregate query
|
|
|
+ if (dialect instanceof PreparedStatementSQLDialect) {
|
|
|
+ st = selectBoundsSQLPS(featureType, query, cx);
|
|
|
+ rs = ((PreparedStatement) st).executeQuery();
|
|
|
+ } else {
|
|
|
+ String sql = selectBoundsSQL(featureType, query);
|
|
|
+ LOGGER.log(Level.FINE, "Retrieving bounding box: {0}", sql);
|
|
|
+
|
|
|
+ st = cx.createStatement();
|
|
|
+ rs = st.executeQuery(sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ // scan through all the rows (just in case a non aggregated function was used)
|
|
|
+ // and through all the columns (in case we have multiple geometry columns)
|
|
|
+ CoordinateReferenceSystem flatCRS =
|
|
|
+ CRS.getHorizontalCRS(featureType.getCoordinateReferenceSystem());
|
|
|
+ final int columns = rs.getMetaData().getColumnCount();
|
|
|
+ while (rs.next()) {
|
|
|
+ for (int i = 1; i <= columns; i++) {
|
|
|
+ final Envelope envelope =
|
|
|
+ dialect.decodeGeometryEnvelope(rs, i, st.getConnection());
|
|
|
+ if (envelope != null) {
|
|
|
+ if (envelope instanceof ReferencedEnvelope) {
|
|
|
+ bounds = mergeEnvelope(bounds, (ReferencedEnvelope) envelope);
|
|
|
+ } else {
|
|
|
+ bounds =
|
|
|
+ mergeEnvelope(
|
|
|
+ bounds, new ReferencedEnvelope(envelope, flatCRS));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } catch (Exception e) {
|
|
|
+ String msg = "Error occured calculating bounds for " + featureType.getTypeName();
|
|
|
+ throw (IOException) new IOException(msg).initCause(e);
|
|
|
+ } finally {
|
|
|
+ closeSafe(rs);
|
|
|
+ closeSafe(st);
|
|
|
+ }
|
|
|
+
|
|
|
+ return bounds;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns true if the query will hit all the geometry columns with no row filtering (a
|
|
|
+ * condition that allows to use spatial index statistics to compute the table bounds)
|
|
|
+ */
|
|
|
+ private boolean isFullBoundsQuery(Query query, SimpleFeatureType schema) {
|
|
|
+ if (query == null) {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ if (!query.isMaxFeaturesUnlimited()) {
|
|
|
+ return false; // there is a limit
|
|
|
+ }
|
|
|
+ if (query.getStartIndex() != null && query.getStartIndex() > 0) {
|
|
|
+ return false; // there is an offset
|
|
|
+ }
|
|
|
+ if (!Filter.INCLUDE.equals(query.getFilter())) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (query.getProperties() == Query.ALL_PROPERTIES) {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ List<String> names = Arrays.asList(query.getPropertyNames());
|
|
|
+ for (AttributeDescriptor ad : schema.getAttributeDescriptors()) {
|
|
|
+ if (ad instanceof GeometryDescriptor) {
|
|
|
+ if (!names.contains(ad.getLocalName())) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Merges two envelopes handling possibly different CRS */
|
|
|
+ ReferencedEnvelope mergeEnvelope(ReferencedEnvelope base, ReferencedEnvelope merge)
|
|
|
+ throws TransformException, FactoryException {
|
|
|
+ if (base == null || base.isNull()) {
|
|
|
+ return merge;
|
|
|
+ } else if (merge == null || merge.isNull()) {
|
|
|
+ return base;
|
|
|
+ } else {
|
|
|
+ // reproject and merge
|
|
|
+ final CoordinateReferenceSystem crsBase = base.getCoordinateReferenceSystem();
|
|
|
+ final CoordinateReferenceSystem crsMerge = merge.getCoordinateReferenceSystem();
|
|
|
+ if (crsBase == null) {
|
|
|
+ merge.expandToInclude(base);
|
|
|
+ return merge;
|
|
|
+ } else if (crsMerge == null) {
|
|
|
+ base.expandToInclude(base);
|
|
|
+ return base;
|
|
|
+ } else {
|
|
|
+ // both not null, are they equal?
|
|
|
+ if (!CRS.equalsIgnoreMetadata(crsBase, crsMerge)) {
|
|
|
+ merge = merge.transform(crsBase, true);
|
|
|
+ }
|
|
|
+ base.expandToInclude(merge);
|
|
|
+ return base;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Returns the count of the features for a particular feature type / table. */
|
|
|
+ protected int getCount(SimpleFeatureType featureType, Query query, Connection cx)
|
|
|
+ throws IOException {
|
|
|
+
|
|
|
+ CountVisitor v = new CountVisitor();
|
|
|
+ getAggregateValue(v, featureType, query, cx);
|
|
|
+ return v.getCount();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Results the value of an aggregate function over a query.
|
|
|
+ *
|
|
|
+ * @return generated result, or null if unsupported
|
|
|
+ */
|
|
|
+ protected Object getAggregateValue(
|
|
|
+ FeatureVisitor visitor, SimpleFeatureType featureType, Query query, Connection cx)
|
|
|
+ throws IOException {
|
|
|
+ // check if group by is supported by the underlying store
|
|
|
+ if (isGroupByVisitor(visitor)
|
|
|
+ && (!dialect.isGroupBySupported()
|
|
|
+ || !isSupportedGroupBy((GroupByVisitor) visitor))) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ // try to match the visitor with an aggregate function
|
|
|
+ String function = matchAggregateFunction(visitor);
|
|
|
+ if (function == null) {
|
|
|
+ // this visitor is not supported
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ // try to extract an aggregate attribute from the visitor
|
|
|
+ Expression aggregateExpression = null;
|
|
|
+ if (!isCountVisitor(visitor)) {
|
|
|
+ aggregateExpression = getAggregateExpression(visitor);
|
|
|
+ if (aggregateExpression != null && !fullySupports(aggregateExpression)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // if the visitor is limiting the result to a given start - max, we will
|
|
|
+ // try to apply limits to the aggregate query
|
|
|
+ LimitingVisitor limitingVisitor = null;
|
|
|
+ if (visitor instanceof LimitingVisitor) {
|
|
|
+ limitingVisitor = (LimitingVisitor) visitor;
|
|
|
+ }
|
|
|
+ // if the visitor is a group by visitor we extract the group by attributes
|
|
|
+ List<Expression> groupByExpressions = extractGroupByExpressions(visitor);
|
|
|
+ // result of the function
|
|
|
+ try {
|
|
|
+ Object result = null;
|
|
|
+ List<Object> results = new ArrayList<>();
|
|
|
+ Statement st = null;
|
|
|
+ ResultSet rs = null;
|
|
|
+
|
|
|
+ try {
|
|
|
+ if (dialect instanceof PreparedStatementSQLDialect) {
|
|
|
+ st =
|
|
|
+ selectAggregateSQLPS(
|
|
|
+ function,
|
|
|
+ aggregateExpression,
|
|
|
+ groupByExpressions,
|
|
|
+ featureType,
|
|
|
+ query,
|
|
|
+ limitingVisitor,
|
|
|
+ cx);
|
|
|
+ rs = ((PreparedStatement) st).executeQuery();
|
|
|
+ } else {
|
|
|
+ String sql =
|
|
|
+ selectAggregateSQL(
|
|
|
+ function,
|
|
|
+ aggregateExpression,
|
|
|
+ groupByExpressions,
|
|
|
+ featureType,
|
|
|
+ query,
|
|
|
+ limitingVisitor);
|
|
|
+ LOGGER.fine(sql);
|
|
|
+
|
|
|
+ st = cx.createStatement();
|
|
|
+ st.setFetchSize(fetchSize);
|
|
|
+ rs = st.executeQuery(sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ // give the dialect an opportunity to convert outputs, if needed, for databases
|
|
|
+ // with a weak/problematic type system (e.g., sqlite)
|
|
|
+ java.util.function.Function<Object, Object> converter =
|
|
|
+ dialect.getAggregateConverter(visitor, featureType);
|
|
|
+
|
|
|
+ while (rs.next()) {
|
|
|
+ if (groupByExpressions == null || groupByExpressions.isEmpty()) {
|
|
|
+ Object value = rs.getObject(1);
|
|
|
+ result = converter.apply(value);
|
|
|
+ results.add(result);
|
|
|
+ } else {
|
|
|
+ results.add(
|
|
|
+ extractValuesFromResultSet(
|
|
|
+ rs, groupByExpressions.size(), converter));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } finally {
|
|
|
+ closeSafe(rs);
|
|
|
+ closeSafe(st);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (groupByExpressions != null && !groupByExpressions.isEmpty()) {
|
|
|
+ setResult(visitor, results);
|
|
|
+ return results;
|
|
|
+ } else if (setResult(visitor, results.size() > 1 ? results : result)) {
|
|
|
+ return result == null ? results : result;
|
|
|
+ }
|
|
|
+
|
|
|
+ return null;
|
|
|
+ } catch (SQLException e) {
|
|
|
+ throw (IOException) new IOException().initCause(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Checks if the groupBy is a supported one, that is, if it's possible to turn to SQL the
|
|
|
+ * various {@link Expression} it's using
|
|
|
+ */
|
|
|
+ private boolean isSupportedGroupBy(GroupByVisitor visitor) {
|
|
|
+ return visitor.getGroupByAttributes().stream().allMatch(xp -> fullySupports(xp));
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Determines if the expression and all its sub expressions are supported.
|
|
|
+ *
|
|
|
+ * @param expression the expression to be tested.
|
|
|
+ * @return true if all sub filters are supported, false otherwise.
|
|
|
+ * @throws IllegalArgumentException If a null filter is passed in. As this function is recursive
|
|
|
+ * a null in a logic filter will also cause an error.
|
|
|
+ */
|
|
|
+ private boolean fullySupports(Expression expression) {
|
|
|
+ if (expression == null) {
|
|
|
+ throw new IllegalArgumentException("Null expression can not be unpacked");
|
|
|
+ }
|
|
|
+
|
|
|
+ FilterCapabilities filterCapabilities = getFilterCapabilities();
|
|
|
+
|
|
|
+ if (!filterCapabilities.supports(expression.getClass())) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ // check the known composite expressions
|
|
|
+ if (expression instanceof BinaryExpression) {
|
|
|
+ BinaryExpression be = (BinaryExpression) expression;
|
|
|
+ return fullySupports(be.getExpression1()) && fullySupports(be.getExpression2());
|
|
|
+ } else if (expression instanceof Function) {
|
|
|
+ Function function = (Function) expression;
|
|
|
+ for (Expression fe : function.getParameters()) {
|
|
|
+ if (!fullySupports(fe)) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Helper method that checks if the visitor is of type count visitor.
|
|
|
+ protected boolean isCountVisitor(FeatureVisitor visitor) {
|
|
|
+ if (visitor instanceof CountVisitor) {
|
|
|
+ // is count visitor nothing else to test
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ // the visitor maybe wrapper by a group by visitor
|
|
|
+ return isGroupByVisitor(visitor)
|
|
|
+ && ((GroupByVisitor) visitor).getAggregateVisitor() instanceof CountVisitor;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Helper method the checks if a feature visitor is a group by visitor,
|
|
|
+ *
|
|
|
+ * @param visitor the feature visitor
|
|
|
+ * @return TRUE if the visitor is a group by visitor otherwise FALSE
|
|
|
+ */
|
|
|
+ protected boolean isGroupByVisitor(FeatureVisitor visitor) {
|
|
|
+ return visitor instanceof GroupByVisitor;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Helper method that will try to match a feature visitor with an aggregate function. If no
|
|
|
+ * aggregate function machs the visitor NULL will be returned.
|
|
|
+ *
|
|
|
+ * @param visitor the feature visitor
|
|
|
+ * @return the match aggregate function name, or NULL if no match
|
|
|
+ */
|
|
|
+ protected String matchAggregateFunction(FeatureVisitor visitor) {
|
|
|
+ // if is a group by visitor we use use the internal aggregate visitor class otherwise we use
|
|
|
+ // the visitor class
|
|
|
+ Class visitorClass =
|
|
|
+ isGroupByVisitor(visitor)
|
|
|
+ ? ((GroupByVisitor) visitor).getAggregateVisitor().getClass()
|
|
|
+ : visitor.getClass();
|
|
|
+ String function = null;
|
|
|
+ // try to find a matching aggregate function walking up the hierarchy if necessary
|
|
|
+ while (function == null && visitorClass != null) {
|
|
|
+ function = getAggregateFunctions().get(visitorClass);
|
|
|
+ visitorClass = visitorClass.getSuperclass();
|
|
|
+ }
|
|
|
+ if (function == null) {
|
|
|
+ // this visitor don't match any aggregate function NULL will be returned
|
|
|
+ LOGGER.info(
|
|
|
+ "Unable to find aggregate function matching visitor: " + visitor.getClass());
|
|
|
+ }
|
|
|
+ return function;
|
|
|
+ }
|
|
|
+
|
|
|
+ private Expression getAggregateExpression(FeatureVisitor visitor) {
|
|
|
+ // if is a group by visitor we need to use the internal aggregate visitor
|
|
|
+ FeatureVisitor aggregateVisitor =
|
|
|
+ isGroupByVisitor(visitor)
|
|
|
+ ? ((GroupByVisitor) visitor).getAggregateVisitor()
|
|
|
+ : visitor;
|
|
|
+ Expression expression = getExpression(aggregateVisitor);
|
|
|
+ if (expression == null) {
|
|
|
+ // no aggregate attribute available, NULL will be returned
|
|
|
+ LOGGER.info("Visitor " + visitor.getClass() + " has no aggregate attribute.");
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ return expression;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Helper method that extracts a list of group by attributes from a group by visitor. If the
|
|
|
+ * visitor is not a group by visitor an empty list will be returned.
|
|
|
+ *
|
|
|
+ * @param visitor the feature visitor
|
|
|
+ * @return the list of the group by attributes or an empty list
|
|
|
+ */
|
|
|
+ protected List<Expression> extractGroupByExpressions(FeatureVisitor visitor) {
|
|
|
+ // if is a group by visitor we get the list of attributes expressions otherwise we get an
|
|
|
+ // empty list
|
|
|
+ List<Expression> expressions =
|
|
|
+ isGroupByVisitor(visitor)
|
|
|
+ ? ((GroupByVisitor) visitor).getGroupByAttributes()
|
|
|
+ : new ArrayList<>();
|
|
|
+ return expressions;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Helper method that translate the result set to the appropriate group by visitor result format
|
|
|
+ */
|
|
|
+ protected GroupByVisitor.GroupByRawResult extractValuesFromResultSet(
|
|
|
+ ResultSet resultSet,
|
|
|
+ int numberOfGroupByAttributes,
|
|
|
+ java.util.function.Function<Object, Object> converter)
|
|
|
+ throws SQLException {
|
|
|
+ List<Object> groupByValues = new ArrayList<>();
|
|
|
+ for (int i = 0; i < numberOfGroupByAttributes; i++) {
|
|
|
+ Object result = resultSet.getObject(i + 1);
|
|
|
+ groupByValues.add(result);
|
|
|
+ }
|
|
|
+ Object aggregated = resultSet.getObject(numberOfGroupByAttributes + 1);
|
|
|
+ Object converted = converter.apply(aggregated);
|
|
|
+ return new GroupByVisitor.GroupByRawResult(groupByValues, converted);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Helper method for getting the expression from a visitor TODO: Remove this method when there
|
|
|
+ * is an interface for aggregate visitors. See GEOT-2325 for details.
|
|
|
+ */
|
|
|
+ Expression getExpression(FeatureVisitor visitor) {
|
|
|
+ if (visitor instanceof CountVisitor) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ Method g = visitor.getClass().getMethod("getExpression", null);
|
|
|
+ if (g != null) {
|
|
|
+ Object result = g.invoke(visitor, null);
|
|
|
+ if (result instanceof Expression) {
|
|
|
+ return (Expression) result;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } catch (Exception e) {
|
|
|
+ // ignore for now
|
|
|
+ }
|
|
|
+
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Helper method for setting the result of a aggregate functino on a visitor. TODO: Remove this
|
|
|
+ * method when there is an interface for aggregate visitors. See GEOT-2325 for details.
|
|
|
+ */
|
|
|
+ boolean setResult(FeatureVisitor visitor, Object result) {
|
|
|
+ try {
|
|
|
+ Method s = null;
|
|
|
+ if (AGGREGATE_SETVALUE_CACHE.containsKey(visitor.getClass())) {
|
|
|
+ s = AGGREGATE_SETVALUE_CACHE.get(visitor.getClass());
|
|
|
+ } else {
|
|
|
+ try {
|
|
|
+ s = visitor.getClass().getMethod("setValue", result.getClass());
|
|
|
+ } catch (Exception e) {
|
|
|
+ }
|
|
|
+
|
|
|
+ if (s == null) {
|
|
|
+ for (Method m : visitor.getClass().getMethods()) {
|
|
|
+ if ("setValue".equals(m.getName()) && m.getParameterCount() == 1) {
|
|
|
+ s = m;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ AGGREGATE_SETVALUE_CACHE.put(visitor.getClass(), s);
|
|
|
+ }
|
|
|
+ if (s != null) {
|
|
|
+ Class<?> type = s.getParameterTypes()[0];
|
|
|
+ if (!type.isInstance(result)) {
|
|
|
+ // convert
|
|
|
+ Object converted = Converters.convert(result, type);
|
|
|
+ if (converted != null) {
|
|
|
+ result = converted;
|
|
|
+ } else {
|
|
|
+ // could not set value
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ s.invoke(visitor, result);
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ } catch (Exception e) {
|
|
|
+ LOGGER.log(
|
|
|
+ Level.INFO,
|
|
|
+ "Failed to set optimized result, will fall back on full collection visit",
|
|
|
+ e);
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Inserts a new feature into the database for a particular feature type / table. */
|
|
|
+ protected void insert(SimpleFeature feature, SimpleFeatureType featureType, Connection cx)
|
|
|
+ throws IOException {
|
|
|
+ insert(Collections.singletonList(feature), featureType, cx);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Inserts a collection of new features into the database for a particular feature type / table.
|
|
|
+ */
|
|
|
+ protected void insert(
|
|
|
+ Collection<? extends SimpleFeature> features,
|
|
|
+ SimpleFeatureType featureType,
|
|
|
+ Connection cx)
|
|
|
+ throws IOException {
|
|
|
+ PrimaryKey key = getPrimaryKey(featureType);
|
|
|
+
|
|
|
+ // we do this in a synchronized block because we need to do two queries,
|
|
|
+ // first to figure out what the id will be, then the insert statement
|
|
|
+ synchronized (this) {
|
|
|
+ try {
|
|
|
+ if (dialect instanceof PreparedStatementSQLDialect) {
|
|
|
+ Map<InsertionClassifier, Collection<SimpleFeature>> kinds =
|
|
|
+ InsertionClassifier.classify(featureType, features);
|
|
|
+ for (InsertionClassifier kind : kinds.keySet()) {
|
|
|
+ insertPS(kinds.get(kind), kind, featureType, cx, key);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ Collection<SimpleFeature> useExistings = new ArrayList<>();
|
|
|
+ Collection<SimpleFeature> notUseExistings = new ArrayList<>();
|
|
|
+ for (SimpleFeature cur : features) {
|
|
|
+ (InsertionClassifier.useExisting(cur) ? useExistings : notUseExistings)
|
|
|
+ .add(cur);
|
|
|
+ }
|
|
|
+ insertNonPS(useExistings, featureType, cx, key, true);
|
|
|
+ insertNonPS(notUseExistings, featureType, cx, key, false);
|
|
|
+ }
|
|
|
+ } catch (SQLException e) {
|
|
|
+ String msg = "Error inserting features";
|
|
|
+ throw (IOException) new IOException(msg).initCause(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Specialized insertion for dialects that are using prepared statements. */
|
|
|
+ private void insertPS(
|
|
|
+ Collection<SimpleFeature> features,
|
|
|
+ InsertionClassifier kind,
|
|
|
+ SimpleFeatureType featureType,
|
|
|
+ Connection cx,
|
|
|
+ PrimaryKey key)
|
|
|
+ throws IOException, SQLException {
|
|
|
+ final PreparedStatementSQLDialect dialect = (PreparedStatementSQLDialect) getSQLDialect();
|
|
|
+
|
|
|
+ final KeysFetcher keysFetcher = KeysFetcher.create(this, cx, kind.useExisting, key);
|
|
|
+
|
|
|
+ final String sql = buildInsertPS(kind, featureType, keysFetcher, dialect);
|
|
|
+ LOGGER.log(Level.FINE, "Inserting new features with ps: {0}", sql);
|
|
|
+
|
|
|
+ // create the prepared statement
|
|
|
+ final PreparedStatement ps;
|
|
|
+ if (keysFetcher.isPostInsert()) {
|
|
|
+ // ask the DB to return the values of all the keys after the insertion
|
|
|
+ ps = cx.prepareStatement(sql, keysFetcher.getColumnNames());
|
|
|
+ } else {
|
|
|
+ ps = cx.prepareStatement(sql);
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ for (SimpleFeature feature : features) {
|
|
|
+ // set the attribute values
|
|
|
+ int i = 1;
|
|
|
+ for (AttributeDescriptor att : featureType.getAttributeDescriptors()) {
|
|
|
+ String colName = att.getLocalName();
|
|
|
+ // skip the pk columns in case we have exposed them, we grab the
|
|
|
+ // value from the pk itself
|
|
|
+ if (keysFetcher.isKey(colName)) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ Class binding = att.getType().getBinding();
|
|
|
+ EnumMapper mapper =
|
|
|
+ (EnumMapper) att.getUserData().get(JDBCDataStore.JDBC_ENUM_MAP);
|
|
|
+
|
|
|
+ Object value = feature.getAttribute(colName);
|
|
|
+ if (value == null && !att.isNillable()) {
|
|
|
+ throw new IOException(
|
|
|
+ "Cannot set a NULL value on the not null column " + colName);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (Geometry.class.isAssignableFrom(binding)) {
|
|
|
+ Geometry g = (Geometry) value;
|
|
|
+ int srid = getGeometrySRID(g, att);
|
|
|
+ int dimension = getGeometryDimension(g, att);
|
|
|
+ dialect.setGeometryValue(g, dimension, srid, binding, ps, i);
|
|
|
+ } else if (this.dialect.isArray(att)) {
|
|
|
+ dialect.setArrayValue(value, att, ps, i, cx);
|
|
|
+ } else {
|
|
|
+ if (mapper != null) {
|
|
|
+ value = mapper.fromString((String) value);
|
|
|
+ binding = Integer.class;
|
|
|
+ }
|
|
|
+ dialect.setValue(value, binding, ps, i, cx);
|
|
|
+ }
|
|
|
+ if (LOGGER.isLoggable(Level.FINE)) {
|
|
|
+ LOGGER.fine((i) + " = " + value);
|
|
|
+ }
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+
|
|
|
+ keysFetcher.setKeyValues(dialect, ps, cx, featureType, feature, i);
|
|
|
+
|
|
|
+ dialect.onInsert(ps, cx, featureType);
|
|
|
+ ps.addBatch();
|
|
|
+ }
|
|
|
+ int[] inserts = ps.executeBatch();
|
|
|
+ checkAllInserted(inserts, features.size());
|
|
|
+ keysFetcher.postInsert(featureType, features, ps);
|
|
|
+ } finally {
|
|
|
+ closeSafe(ps);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ static void checkAllInserted(int[] inserts, int size) throws IOException {
|
|
|
+ int sum = 0;
|
|
|
+ for (int cur : inserts) {
|
|
|
+ if (cur == PreparedStatement.SUCCESS_NO_INFO) {
|
|
|
+ return; // cannot check
|
|
|
+ } else if (cur == PreparedStatement.EXECUTE_FAILED) {
|
|
|
+ throw new IOException("Failed to insert some features");
|
|
|
+ }
|
|
|
+ sum += cur;
|
|
|
+ }
|
|
|
+ if (sum != size) {
|
|
|
+ throw new IOException("Failed to insert some features");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Build the insert statement that will be used in a PreparedStatement. */
|
|
|
+ private String buildInsertPS(
|
|
|
+ InsertionClassifier kind,
|
|
|
+ SimpleFeatureType featureType,
|
|
|
+ KeysFetcher keysFetcher,
|
|
|
+ PreparedStatementSQLDialect dialect)
|
|
|
+ throws SQLException {
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("INSERT INTO ");
|
|
|
+ encodeTableName(featureType.getTypeName(), sql, null);
|
|
|
+
|
|
|
+ // column names
|
|
|
+ sql.append(" ( ");
|
|
|
+
|
|
|
+ for (int i = 0; i < featureType.getAttributeCount(); i++) {
|
|
|
+ String colName = featureType.getDescriptor(i).getLocalName();
|
|
|
+ // skip the pk columns in case we have exposed them
|
|
|
+ if (keysFetcher.isKey(colName)) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ dialect.encodeColumnName(null, colName, sql);
|
|
|
+ sql.append(",");
|
|
|
+ }
|
|
|
+
|
|
|
+ // primary key values
|
|
|
+ keysFetcher.addKeyColumns(sql);
|
|
|
+ sql.setLength(sql.length() - 1); // remove the last coma
|
|
|
+
|
|
|
+ // values
|
|
|
+ sql.append(" ) VALUES ( ");
|
|
|
+ for (AttributeDescriptor att : featureType.getAttributeDescriptors()) {
|
|
|
+ String colName = att.getLocalName();
|
|
|
+ // skip the pk columns in case we have exposed them, we grab the
|
|
|
+ // value from the pk itself
|
|
|
+ if (keysFetcher.isKey(colName)) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // geometries might need special treatment, delegate to the dialect
|
|
|
+ if (att instanceof GeometryDescriptor) {
|
|
|
+ Class<? extends Geometry> geometryClass =
|
|
|
+ kind.geometryTypes.get(att.getName().getLocalPart());
|
|
|
+ dialect.prepareGeometryValue(
|
|
|
+ geometryClass,
|
|
|
+ getDescriptorDimension(att),
|
|
|
+ getDescriptorSRID(att),
|
|
|
+ att.getType().getBinding(),
|
|
|
+ sql);
|
|
|
+ } else {
|
|
|
+ sql.append("?");
|
|
|
+ }
|
|
|
+ sql.append(",");
|
|
|
+ }
|
|
|
+ keysFetcher.addKeyBindings(sql);
|
|
|
+
|
|
|
+ sql.setLength(sql.length() - 1);
|
|
|
+ sql.append(")");
|
|
|
+ return sql.toString();
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Specialized insertion for dialects that are not using prepared statements. */
|
|
|
+ private void insertNonPS(
|
|
|
+ Collection<? extends SimpleFeature> features,
|
|
|
+ SimpleFeatureType featureType,
|
|
|
+ Connection cx,
|
|
|
+ PrimaryKey key,
|
|
|
+ boolean useExisting)
|
|
|
+ throws IOException, SQLException {
|
|
|
+ if (features.isEmpty()) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ final Statement st = cx.createStatement();
|
|
|
+ final KeysFetcher keysFetcher = KeysFetcher.create(this, cx, useExisting, key);
|
|
|
+ try {
|
|
|
+ for (SimpleFeature feature : features) {
|
|
|
+ String sql = insertSQL(featureType, feature, keysFetcher, cx);
|
|
|
+
|
|
|
+ ((BasicSQLDialect) dialect).onInsert(st, cx, featureType);
|
|
|
+
|
|
|
+ LOGGER.log(Level.FINE, "Inserting new feature: {0}", sql);
|
|
|
+ if (keysFetcher.hasAutoGeneratedKeys()) {
|
|
|
+ st.executeUpdate(sql, Statement.RETURN_GENERATED_KEYS);
|
|
|
+ } else {
|
|
|
+ st.executeUpdate(sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ keysFetcher.postInsert(featureType, feature, cx, st);
|
|
|
+ }
|
|
|
+ } finally {
|
|
|
+ closeSafe(st);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Updates an existing feature(s) in the database for a particular feature type / table. */
|
|
|
+ protected void update(
|
|
|
+ SimpleFeatureType featureType,
|
|
|
+ List<AttributeDescriptor> attributes,
|
|
|
+ List<Object> values,
|
|
|
+ Filter filter,
|
|
|
+ Connection cx)
|
|
|
+ throws IOException, SQLException {
|
|
|
+ update(
|
|
|
+ featureType,
|
|
|
+ attributes.toArray(new AttributeDescriptor[attributes.size()]),
|
|
|
+ values.toArray(new Object[values.size()]),
|
|
|
+ filter,
|
|
|
+ cx);
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Updates an existing feature(s) in the database for a particular feature type / table. */
|
|
|
+ protected void update(
|
|
|
+ SimpleFeatureType featureType,
|
|
|
+ AttributeDescriptor[] attributes,
|
|
|
+ Object[] values,
|
|
|
+ Filter filter,
|
|
|
+ Connection cx)
|
|
|
+ throws IOException, SQLException {
|
|
|
+ if ((attributes == null) || (attributes.length == 0)) {
|
|
|
+ LOGGER.warning("Update called with no attributes, doing nothing.");
|
|
|
+
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // grab primary key
|
|
|
+ PrimaryKey key = null;
|
|
|
+ try {
|
|
|
+ key = getPrimaryKey(featureType);
|
|
|
+ } catch (IOException e) {
|
|
|
+ throw new RuntimeException(e);
|
|
|
+ }
|
|
|
+ Set<String> pkColumnNames = getColumnNames(key);
|
|
|
+
|
|
|
+ // do a check to ensure that the update includes at least one non primary key column
|
|
|
+ boolean nonPkeyColumn = false;
|
|
|
+ for (AttributeDescriptor att : attributes) {
|
|
|
+ if (!pkColumnNames.contains(att.getLocalName())) {
|
|
|
+ nonPkeyColumn = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!nonPkeyColumn) {
|
|
|
+ throw new IllegalArgumentException(
|
|
|
+ "Illegal update, must include at least one non primary key column, "
|
|
|
+ + "all primary key columns are ignored.");
|
|
|
+ }
|
|
|
+ if (dialect instanceof PreparedStatementSQLDialect) {
|
|
|
+ try {
|
|
|
+ PreparedStatement ps =
|
|
|
+ updateSQLPS(featureType, attributes, values, filter, pkColumnNames, cx);
|
|
|
+ try {
|
|
|
+ ((PreparedStatementSQLDialect) dialect).onUpdate(ps, cx, featureType);
|
|
|
+ ps.execute();
|
|
|
+ } finally {
|
|
|
+ closeSafe(ps);
|
|
|
+ }
|
|
|
+ } catch (SQLException e) {
|
|
|
+ throw new RuntimeException(e);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ String sql = updateSQL(featureType, attributes, values, filter, pkColumnNames);
|
|
|
+
|
|
|
+ try {
|
|
|
+ Statement st = cx.createStatement();
|
|
|
+
|
|
|
+ try {
|
|
|
+ ((BasicSQLDialect) dialect).onUpdate(st, cx, featureType);
|
|
|
+
|
|
|
+ LOGGER.log(Level.FINE, "Updating feature: {0}", sql);
|
|
|
+ st.execute(sql);
|
|
|
+ } finally {
|
|
|
+ closeSafe(st);
|
|
|
+ }
|
|
|
+ } catch (SQLException e) {
|
|
|
+ String msg = "Error occured updating features";
|
|
|
+ throw (IOException) new IOException(msg).initCause(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Deletes an existing feature in the database for a particular feature type / fid. */
|
|
|
+ protected void delete(SimpleFeatureType featureType, String fid, Connection cx)
|
|
|
+ throws IOException {
|
|
|
+ Filter filter = filterFactory.id(Collections.singleton(filterFactory.featureId(fid)));
|
|
|
+ delete(featureType, filter, cx);
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Deletes an existing feature(s) in the database for a particular feature type / table. */
|
|
|
+ protected void delete(SimpleFeatureType featureType, Filter filter, Connection cx)
|
|
|
+ throws IOException {
|
|
|
+
|
|
|
+ Statement st = null;
|
|
|
+ try {
|
|
|
+ try {
|
|
|
+ if (dialect instanceof PreparedStatementSQLDialect) {
|
|
|
+ st = deleteSQLPS(featureType, filter, cx);
|
|
|
+ @SuppressWarnings("PMD.CloseResource") // actually being closed later
|
|
|
+ PreparedStatement ps = (PreparedStatement) st;
|
|
|
+
|
|
|
+ ((PreparedStatementSQLDialect) dialect).onDelete(ps, cx, featureType);
|
|
|
+ ps.execute();
|
|
|
+ } else {
|
|
|
+ String sql = deleteSQL(featureType, filter);
|
|
|
+
|
|
|
+ st = cx.createStatement();
|
|
|
+ ((BasicSQLDialect) dialect).onDelete(st, cx, featureType);
|
|
|
+
|
|
|
+ LOGGER.log(Level.FINE, "Removing feature(s): {0}", sql);
|
|
|
+ st.execute(sql);
|
|
|
+ }
|
|
|
+ } finally {
|
|
|
+ closeSafe(st);
|
|
|
+ }
|
|
|
+ } catch (SQLException e) {
|
|
|
+ String msg = "Error occured during delete";
|
|
|
+ throw (IOException) new IOException(msg).initCause(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns a JDBC Connection to the underlying database for the specified GeoTools {@link
|
|
|
+ * Transaction}. This has two main use cases:
|
|
|
+ *
|
|
|
+ * <ul>
|
|
|
+ * <li>Independently accessing the underlying database directly reusing the connection pool
|
|
|
+ * contained in the {@link JDBCDataStore}
|
|
|
+ * <li>Performing some direct access to the database in the same JDBC transaction as the
|
|
|
+ * Geotools code
|
|
|
+ * </ul>
|
|
|
+ *
|
|
|
+ * The connection shall be used in a different way depending on the use case:
|
|
|
+ *
|
|
|
+ * <ul>
|
|
|
+ * <li>If the transaction is {@link Transaction#AUTO_COMMIT} or if the transaction is not
|
|
|
+ * shared with this data store and originating {@link FeatureStore} objects it is the duty
|
|
|
+ * of the caller to properly close the connection after usage, failure to do so will
|
|
|
+ * result in the connection pool loose one available connection permanently
|
|
|
+ * <li>If the transaction is on the other side a valid transaction is shared with Geotools the
|
|
|
+ * client code should refrain from closing the connection, committing or rolling back, and
|
|
|
+ * use the {@link Transaction} facilities to do so instead
|
|
|
+ * </ul>
|
|
|
+ *
|
|
|
+ * @param t The GeoTools transaction. Can be {@code null}, in that case a new connection will be
|
|
|
+ * returned (as if {@link Transaction#AUTO_COMMIT} was provided)
|
|
|
+ */
|
|
|
+ public Connection getConnection(Transaction t) throws IOException {
|
|
|
+ // short circuit this state, all auto commit transactions are using the same
|
|
|
+ if (t == Transaction.AUTO_COMMIT) {
|
|
|
+ Connection cx = createConnection();
|
|
|
+ try {
|
|
|
+ if (!cx.getAutoCommit()) {
|
|
|
+ cx.setAutoCommit(true);
|
|
|
+ }
|
|
|
+ } catch (SQLException e) {
|
|
|
+ throw (IOException) new IOException().initCause(e);
|
|
|
+ }
|
|
|
+ return cx;
|
|
|
+ }
|
|
|
+
|
|
|
+ JDBCTransactionState tstate = (JDBCTransactionState) t.getState(this);
|
|
|
+ if (tstate != null) {
|
|
|
+ return tstate.cx;
|
|
|
+ } else {
|
|
|
+ Connection cx = createConnection();
|
|
|
+ try {
|
|
|
+ cx.setAutoCommit(false);
|
|
|
+ } catch (SQLException e) {
|
|
|
+ throw (IOException) new IOException().initCause(e);
|
|
|
+ }
|
|
|
+
|
|
|
+ tstate = new JDBCTransactionState(cx, this);
|
|
|
+ t.putState(this, tstate);
|
|
|
+ return cx;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Gets a database connection for the specified feature store. */
|
|
|
+ protected final Connection getConnection(JDBCState state) throws IOException {
|
|
|
+ return getConnection(state.getTransaction());
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates a new connection.
|
|
|
+ *
|
|
|
+ * <p>Callers of this method should close the connection when done with it. .
|
|
|
+ */
|
|
|
+ protected final Connection createConnection() {
|
|
|
+ try {
|
|
|
+ LOGGER.fine("CREATE CONNECTION");
|
|
|
+
|
|
|
+ Connection cx = getDataSource().getConnection();
|
|
|
+
|
|
|
+ // isolation level is not set in the datastore, see
|
|
|
+ // http://jira.codehaus.org/browse/GEOT-2021
|
|
|
+
|
|
|
+ // call dialect callback to initialize the connection
|
|
|
+ dialect.initializeConnection(cx);
|
|
|
+
|
|
|
+ // if there is any lifecycle listener use it
|
|
|
+ if (!connectionLifecycleListeners.isEmpty()) {
|
|
|
+ List<ConnectionLifecycleListener> locals =
|
|
|
+ new ArrayList<>(connectionLifecycleListeners);
|
|
|
+ return new LifecycleConnection(this, cx, locals);
|
|
|
+ }
|
|
|
+ return cx;
|
|
|
+ } catch (SQLException e) {
|
|
|
+ throw new RuntimeException("Unable to obtain connection: " + e.getMessage(), e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Releases an existing connection (paying special attention to {@link Transaction#AUTO_COMMIT}.
|
|
|
+ *
|
|
|
+ * <p>If the state is based off the AUTO_COMMIT transaction - close using {@link
|
|
|
+ * #closeSafe(Connection)}. Otherwise wait until the transaction itself is closed to close the
|
|
|
+ * connection.
|
|
|
+ */
|
|
|
+ protected final void releaseConnection(Connection cx, JDBCState state) {
|
|
|
+ if (state.getTransaction() == Transaction.AUTO_COMMIT) {
|
|
|
+ closeSafe(cx);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Calls through to: <code><pre>
|
|
|
+ * encodeFID(pkey, rs, 0);
|
|
|
+ * </pre></code>
|
|
|
+ */
|
|
|
+ public String encodeFID(PrimaryKey pkey, ResultSet rs) throws SQLException, IOException {
|
|
|
+ return encodeFID(pkey, rs, 0);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Encodes a feature id from a primary key and result set values.
|
|
|
+ *
|
|
|
+ * <p><tt>offset</tt> specifies where in the result set to start from when reading values for
|
|
|
+ * the primary key.
|
|
|
+ */
|
|
|
+ protected String encodeFID(PrimaryKey pkey, ResultSet rs, int offset)
|
|
|
+ throws SQLException, IOException {
|
|
|
+ // no pk columns
|
|
|
+ List<PrimaryKeyColumn> columns = pkey.getColumns();
|
|
|
+ if (columns.isEmpty()) {
|
|
|
+ return SimpleFeatureBuilder.createDefaultFeatureId();
|
|
|
+ }
|
|
|
+
|
|
|
+ // just one, no need to build support structures
|
|
|
+ if (columns.size() == 1) {
|
|
|
+ return dialect.getPkColumnValue(rs, columns.get(0), offset + 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ // more than one
|
|
|
+ List<Object> keyValues = new ArrayList<>();
|
|
|
+ for (int i = 0; i < columns.size(); i++) {
|
|
|
+ String o = dialect.getPkColumnValue(rs, columns.get(0), offset + i + 1);
|
|
|
+ keyValues.add(o);
|
|
|
+ }
|
|
|
+ return encodeFID(keyValues);
|
|
|
+ }
|
|
|
+
|
|
|
+ protected static String encodeFID(List<Object> keyValues) {
|
|
|
+ StringBuffer fid = new StringBuffer();
|
|
|
+ for (Object o : keyValues) {
|
|
|
+ fid.append(o).append(".");
|
|
|
+ }
|
|
|
+ fid.setLength(fid.length() - 1);
|
|
|
+ return fid.toString();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Decodes a fid into its components based on a primary key.
|
|
|
+ *
|
|
|
+ * @param strict If set to true the value of the fid will be validated against the type of the
|
|
|
+ * key columns. If a conversion can not be made, an exception will be thrown.
|
|
|
+ */
|
|
|
+ public static List<Object> decodeFID(PrimaryKey key, String FID, boolean strict) {
|
|
|
+ // strip off the feature type name
|
|
|
+ if (FID.startsWith(key.getTableName() + ".")) {
|
|
|
+ FID = FID.substring(key.getTableName().length() + 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ try {
|
|
|
+ FID = URLDecoder.decode(FID, "UTF-8");
|
|
|
+ } catch (UnsupportedEncodingException e) {
|
|
|
+ throw new RuntimeException(e);
|
|
|
+ }
|
|
|
+
|
|
|
+ // check for case of multi column primary key and try to backwards map using
|
|
|
+ // "." as a seperator of values
|
|
|
+ List<Object> values = null;
|
|
|
+ if (key.getColumns().size() > 1) {
|
|
|
+ String[] split = FID.split("\\.");
|
|
|
+
|
|
|
+ // copy over to avoid array store exception
|
|
|
+ values = new ArrayList<>(split.length);
|
|
|
+ for (String s : split) {
|
|
|
+ values.add(s);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ // single value case
|
|
|
+ values = new ArrayList<>();
|
|
|
+ values.add(FID);
|
|
|
+ }
|
|
|
+ if (values.size() != key.getColumns().size()) {
|
|
|
+ throw new IllegalArgumentException(
|
|
|
+ "Illegal fid: "
|
|
|
+ + FID
|
|
|
+ + ". Expected "
|
|
|
+ + key.getColumns().size()
|
|
|
+ + " values but got "
|
|
|
+ + values.size());
|
|
|
+ }
|
|
|
+
|
|
|
+ // convert to the type of the key
|
|
|
+ for (int i = 0; i < values.size(); i++) {
|
|
|
+ Object value = values.get(i);
|
|
|
+ if (value != null) {
|
|
|
+ Class<?> type = key.getColumns().get(i).getType();
|
|
|
+ Object converted = Converters.convert(value, type);
|
|
|
+ if (converted != null) {
|
|
|
+ values.set(i, converted);
|
|
|
+ }
|
|
|
+ if (strict && !type.isInstance(values.get(i))) {
|
|
|
+ throw new IllegalArgumentException(
|
|
|
+ "Value " + values.get(i) + " illegal for type " + type.getName());
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return values;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Determines if a primary key is made up entirely of column which are generated via an
|
|
|
+ * auto-generating column or a sequence.
|
|
|
+ */
|
|
|
+ protected boolean isGenerated(PrimaryKey pkey) {
|
|
|
+ for (PrimaryKeyColumn col : pkey.getColumns()) {
|
|
|
+ if (!(col instanceof AutoGeneratedPrimaryKeyColumn)) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ //
|
|
|
+ // SQL generation
|
|
|
+ //
|
|
|
+ /** Generates a 'CREATE TABLE' sql statement. */
|
|
|
+ protected String createTableSQL(SimpleFeatureType featureType, Connection cx) throws Exception {
|
|
|
+ // figure out the names and types of the columns
|
|
|
+ String[] columnNames = new String[featureType.getAttributeCount()];
|
|
|
+ Class[] classes = new Class[featureType.getAttributeCount()];
|
|
|
+
|
|
|
+ // figure out which columns can not be null
|
|
|
+ boolean[] nillable = new boolean[featureType.getAttributeCount()];
|
|
|
+
|
|
|
+ for (int i = 0; i < featureType.getAttributeCount(); i++) {
|
|
|
+ AttributeDescriptor attributeType = featureType.getDescriptor(i);
|
|
|
+
|
|
|
+ // column name
|
|
|
+ columnNames[i] = attributeType.getLocalName();
|
|
|
+
|
|
|
+ // column type
|
|
|
+ classes[i] = attributeType.getType().getBinding();
|
|
|
+
|
|
|
+ // can be null?
|
|
|
+ nillable[i] = attributeType.getMinOccurs() <= 0 || attributeType.isNillable();
|
|
|
+
|
|
|
+ // eventual options
|
|
|
+ }
|
|
|
+
|
|
|
+ String[] sqlTypeNames = getSQLTypeNames(featureType.getAttributeDescriptors(), cx);
|
|
|
+ for (int i = 0; i < sqlTypeNames.length; i++) {
|
|
|
+ if (sqlTypeNames[i] == null) {
|
|
|
+ String msg = "Unable to map " + columnNames[i] + "( " + classes[i].getName() + ")";
|
|
|
+ throw new RuntimeException(msg);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return createTableSQL(
|
|
|
+ featureType.getTypeName(),
|
|
|
+ columnNames,
|
|
|
+ sqlTypeNames,
|
|
|
+ nillable,
|
|
|
+ findPrimaryKeyColumnName(featureType),
|
|
|
+ featureType);
|
|
|
+ }
|
|
|
+
|
|
|
+ /*
|
|
|
+ * search feature type looking for suitable unique column for primary key.
|
|
|
+ */
|
|
|
+ protected String findPrimaryKeyColumnName(SimpleFeatureType featureType) {
|
|
|
+ String[] suffix = {"", "_1", "_2"};
|
|
|
+ String[] base = {"fid", "id", "gt_id", "ogc_fid"};
|
|
|
+
|
|
|
+ for (String b : base) {
|
|
|
+ O:
|
|
|
+ for (String s : suffix) {
|
|
|
+ String name = b + s;
|
|
|
+ for (AttributeDescriptor ad : featureType.getAttributeDescriptors()) {
|
|
|
+ if (ad.getLocalName().equalsIgnoreCase(name)) {
|
|
|
+ continue O;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return name;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // practically should never get here, but just fall back and fail later
|
|
|
+ return "fid";
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Generates a 'DROP TABLE' sql statement. */
|
|
|
+ protected String dropTableSQL(SimpleFeatureType featureType, Connection cx) throws Exception {
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("DROP TABLE ");
|
|
|
+
|
|
|
+ encodeTableName(featureType.getTypeName(), sql, null);
|
|
|
+
|
|
|
+ return sql.toString();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Ensures that that the specified transaction has access to features specified by a filter.
|
|
|
+ *
|
|
|
+ * <p>If any features matching the filter are locked, and the transaction does not have
|
|
|
+ * authorization with respect to the lock, an exception is thrown.
|
|
|
+ *
|
|
|
+ * @param featureType The feature type / table.
|
|
|
+ * @param filter The filters.
|
|
|
+ * @param tx The transaction.
|
|
|
+ * @param cx The database connection.
|
|
|
+ */
|
|
|
+ protected void ensureAuthorization(
|
|
|
+ SimpleFeatureType featureType, Filter filter, Transaction tx, Connection cx)
|
|
|
+ throws IOException, SQLException {
|
|
|
+
|
|
|
+ InProcessLockingManager lm = (InProcessLockingManager) getLockingManager();
|
|
|
+ // verify if we have any lock to check
|
|
|
+ Map locks = lm.locks(featureType.getTypeName());
|
|
|
+ if (!locks.isEmpty()) {
|
|
|
+ // limiting query to only extract locked features
|
|
|
+ if (locks.size() <= MAX_IDS_IN_FILTER) {
|
|
|
+ Set<FeatureId> ids = getLockedIds(locks);
|
|
|
+ Id lockFilter = getFilterFactory().id(ids);
|
|
|
+ // intersect given filter with ids filter
|
|
|
+ filter = getFilterFactory().and(filter, lockFilter);
|
|
|
+ }
|
|
|
+ Query query = new Query(featureType.getTypeName(), filter, Query.NO_NAMES);
|
|
|
+
|
|
|
+ Statement st = null;
|
|
|
+ try {
|
|
|
+ ResultSet rs = null;
|
|
|
+ if (getSQLDialect() instanceof PreparedStatementSQLDialect) {
|
|
|
+ st = selectSQLPS(featureType, query, cx);
|
|
|
+
|
|
|
+ @SuppressWarnings("PMD.CloseResource") // actually being closed later
|
|
|
+ PreparedStatement ps = (PreparedStatement) st;
|
|
|
+ ((PreparedStatementSQLDialect) getSQLDialect()).onSelect(ps, cx, featureType);
|
|
|
+ rs = ps.executeQuery();
|
|
|
+ } else {
|
|
|
+ String sql = selectSQL(featureType, query);
|
|
|
+
|
|
|
+ st = cx.createStatement();
|
|
|
+ st.setFetchSize(fetchSize);
|
|
|
+ ((BasicSQLDialect) getSQLDialect()).onSelect(st, cx, featureType);
|
|
|
+
|
|
|
+ LOGGER.fine(sql);
|
|
|
+ rs = st.executeQuery(sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ try {
|
|
|
+ PrimaryKey key = getPrimaryKey(featureType);
|
|
|
+
|
|
|
+ while (rs.next()) {
|
|
|
+ String fid = featureType.getTypeName() + "." + encodeFID(key, rs);
|
|
|
+ lm.assertAccess(featureType.getTypeName(), fid, tx);
|
|
|
+ }
|
|
|
+ } finally {
|
|
|
+ closeSafe(rs);
|
|
|
+ }
|
|
|
+ } finally {
|
|
|
+ closeSafe(st);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Extracts a set of FeatureId objects from the locks Map. */
|
|
|
+ private Set<FeatureId> getLockedIds(Map locks) {
|
|
|
+ Set<FeatureId> ids = new HashSet<>();
|
|
|
+ for (Object lock : locks.keySet()) {
|
|
|
+ ids.add(getFilterFactory().featureId(lock.toString()));
|
|
|
+ }
|
|
|
+ return ids;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Helper method for creating geometry association table if it does not exist. */
|
|
|
+ protected void ensureAssociationTablesExist(Connection cx) throws IOException, SQLException {
|
|
|
+ // look for feature relationship table
|
|
|
+ DatabaseMetaData metadata = cx.getMetaData();
|
|
|
+ ResultSet tables =
|
|
|
+ metadata.getTables(
|
|
|
+ null,
|
|
|
+ escapeNamePattern(metadata, databaseSchema),
|
|
|
+ escapeNamePattern(metadata, FEATURE_RELATIONSHIP_TABLE),
|
|
|
+ null);
|
|
|
+
|
|
|
+ try {
|
|
|
+ if (!tables.next()) {
|
|
|
+ // does not exist, create it
|
|
|
+ String sql = createRelationshipTableSQL(cx);
|
|
|
+ LOGGER.log(Level.FINE, "Creating relationship table: {0}", sql);
|
|
|
+
|
|
|
+ Statement st = cx.createStatement();
|
|
|
+
|
|
|
+ try {
|
|
|
+ st.execute(sql);
|
|
|
+ } finally {
|
|
|
+ closeSafe(st);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } finally {
|
|
|
+ closeSafe(tables);
|
|
|
+ }
|
|
|
+
|
|
|
+ // look for feature association table
|
|
|
+ tables =
|
|
|
+ metadata.getTables(
|
|
|
+ null,
|
|
|
+ escapeNamePattern(metadata, databaseSchema),
|
|
|
+ escapeNamePattern(metadata, FEATURE_ASSOCIATION_TABLE),
|
|
|
+ null);
|
|
|
+
|
|
|
+ try {
|
|
|
+ if (!tables.next()) {
|
|
|
+ // does not exist, create it
|
|
|
+ String sql = createAssociationTableSQL(cx);
|
|
|
+ LOGGER.log(Level.FINE, "Creating association table: {0}", sql);
|
|
|
+
|
|
|
+ Statement st = cx.createStatement();
|
|
|
+
|
|
|
+ try {
|
|
|
+ st.execute(sql);
|
|
|
+ } finally {
|
|
|
+ closeSafe(st);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } finally {
|
|
|
+ closeSafe(tables);
|
|
|
+ }
|
|
|
+
|
|
|
+ // look up for geometry table
|
|
|
+ tables =
|
|
|
+ metadata.getTables(
|
|
|
+ null,
|
|
|
+ escapeNamePattern(metadata, databaseSchema),
|
|
|
+ escapeNamePattern(metadata, GEOMETRY_TABLE),
|
|
|
+ null);
|
|
|
+
|
|
|
+ try {
|
|
|
+ if (!tables.next()) {
|
|
|
+ // does not exist, create it
|
|
|
+ String sql = createGeometryTableSQL(cx);
|
|
|
+ LOGGER.log(Level.FINE, "Creating geometry table: {0}", sql);
|
|
|
+
|
|
|
+ Statement st = cx.createStatement();
|
|
|
+
|
|
|
+ try {
|
|
|
+ st.execute(sql);
|
|
|
+ } finally {
|
|
|
+ closeSafe(st);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } finally {
|
|
|
+ closeSafe(tables);
|
|
|
+ }
|
|
|
+
|
|
|
+ // look up for multi geometry table
|
|
|
+ tables =
|
|
|
+ metadata.getTables(
|
|
|
+ null,
|
|
|
+ escapeNamePattern(metadata, databaseSchema),
|
|
|
+ escapeNamePattern(metadata, MULTI_GEOMETRY_TABLE),
|
|
|
+ null);
|
|
|
+
|
|
|
+ try {
|
|
|
+ if (!tables.next()) {
|
|
|
+ // does not exist, create it
|
|
|
+ String sql = createMultiGeometryTableSQL(cx);
|
|
|
+ LOGGER.log(Level.FINE, "Creating multi-geometry table: {0}", sql);
|
|
|
+
|
|
|
+ Statement st = cx.createStatement();
|
|
|
+
|
|
|
+ try {
|
|
|
+ st.execute(sql);
|
|
|
+ } finally {
|
|
|
+ closeSafe(st);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } finally {
|
|
|
+ closeSafe(tables);
|
|
|
+ }
|
|
|
+
|
|
|
+ // look up for metadata for geometry association table
|
|
|
+ tables =
|
|
|
+ metadata.getTables(
|
|
|
+ null,
|
|
|
+ escapeNamePattern(metadata, databaseSchema),
|
|
|
+ escapeNamePattern(metadata, GEOMETRY_ASSOCIATION_TABLE),
|
|
|
+ null);
|
|
|
+
|
|
|
+ try {
|
|
|
+ if (!tables.next()) {
|
|
|
+ // does not exist, create it
|
|
|
+ String sql = createGeometryAssociationTableSQL(cx);
|
|
|
+ LOGGER.log(Level.FINE, "Creating geometry association table: {0}", sql);
|
|
|
+
|
|
|
+ Statement st = cx.createStatement();
|
|
|
+
|
|
|
+ try {
|
|
|
+ st.execute(sql);
|
|
|
+ } finally {
|
|
|
+ closeSafe(st);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } finally {
|
|
|
+ closeSafe(tables);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates the sql for the relationship table.
|
|
|
+ *
|
|
|
+ * <p>This method is only called when {@link JDBCDataStore#isAssociations()} is true.
|
|
|
+ */
|
|
|
+ protected String createRelationshipTableSQL(Connection cx) throws SQLException {
|
|
|
+ String[] sqlTypeNames = getSQLTypeNames(descriptors(String.class, String.class), cx);
|
|
|
+ String[] columnNames = {"table", "col"};
|
|
|
+
|
|
|
+ return createTableSQL(
|
|
|
+ FEATURE_RELATIONSHIP_TABLE, columnNames, sqlTypeNames, null, null, null);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates the sql for the association table.
|
|
|
+ *
|
|
|
+ * <p>This method is only called when {@link JDBCDataStore#isAssociations()} is true.
|
|
|
+ */
|
|
|
+ protected String createAssociationTableSQL(Connection cx) throws SQLException {
|
|
|
+ String[] sqlTypeNames =
|
|
|
+ getSQLTypeNames(
|
|
|
+ descriptors(String.class, String.class, String.class, String.class), cx);
|
|
|
+ String[] columnNames = {"fid", "rtable", "rcol", "rfid"};
|
|
|
+
|
|
|
+ return createTableSQL(
|
|
|
+ FEATURE_ASSOCIATION_TABLE, columnNames, sqlTypeNames, null, null, null);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates the sql for the geometry table.
|
|
|
+ *
|
|
|
+ * <p>This method is only called when {@link JDBCDataStore#isAssociations()} is true.
|
|
|
+ */
|
|
|
+ protected String createGeometryTableSQL(Connection cx) throws SQLException {
|
|
|
+ String[] sqlTypeNames =
|
|
|
+ getSQLTypeNames(
|
|
|
+ descriptors(
|
|
|
+ String.class,
|
|
|
+ String.class,
|
|
|
+ String.class,
|
|
|
+ String.class,
|
|
|
+ Geometry.class),
|
|
|
+ cx);
|
|
|
+ String[] columnNames = {"id", "name", "description", "type", "geometry"};
|
|
|
+
|
|
|
+ return createTableSQL(GEOMETRY_TABLE, columnNames, sqlTypeNames, null, null, null);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates the sql for the multi_geometry table.
|
|
|
+ *
|
|
|
+ * <p>This method is only called when {@link JDBCDataStore#isAssociations()} is true.
|
|
|
+ */
|
|
|
+ protected String createMultiGeometryTableSQL(Connection cx) throws SQLException {
|
|
|
+ String[] sqlTypeNames =
|
|
|
+ getSQLTypeNames(descriptors(String.class, String.class, Boolean.class), cx);
|
|
|
+ String[] columnNames = {"id", "mgid", "ref"};
|
|
|
+
|
|
|
+ return createTableSQL(MULTI_GEOMETRY_TABLE, columnNames, sqlTypeNames, null, null, null);
|
|
|
+ }
|
|
|
+
|
|
|
+ private List<AttributeDescriptor> descriptors(Class<?>... classes) {
|
|
|
+ AttributeTypeBuilder tb = new AttributeTypeBuilder();
|
|
|
+ List<AttributeDescriptor> result = new ArrayList<>();
|
|
|
+ for (int i = 0; i < classes.length; i++) {
|
|
|
+ Class<?> aClass = classes[i];
|
|
|
+ AttributeDescriptor ad = tb.name("a" + i).binding(aClass).buildDescriptor("a" + i);
|
|
|
+ result.add(ad);
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates the sql for the relationship table.
|
|
|
+ *
|
|
|
+ * <p>This method is only called when {@link JDBCDataStore#isAssociations()} is true.
|
|
|
+ *
|
|
|
+ * @param table The table of the association
|
|
|
+ * @param column The column of the association
|
|
|
+ */
|
|
|
+ protected String selectRelationshipSQL(String table, String column) throws SQLException {
|
|
|
+ BasicSQLDialect dialect = (BasicSQLDialect) getSQLDialect();
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("SELECT ");
|
|
|
+ dialect.encodeColumnName(null, "table", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "col", sql);
|
|
|
+
|
|
|
+ sql.append(" FROM ");
|
|
|
+ encodeTableName(FEATURE_RELATIONSHIP_TABLE, sql, null);
|
|
|
+
|
|
|
+ if (table != null) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+
|
|
|
+ dialect.encodeColumnName(null, "table", sql);
|
|
|
+ sql.append(" = ");
|
|
|
+ dialect.encodeValue(table, String.class, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (column != null) {
|
|
|
+ if (table == null) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+ } else {
|
|
|
+ sql.append(" AND ");
|
|
|
+ }
|
|
|
+
|
|
|
+ dialect.encodeColumnName(null, "col", sql);
|
|
|
+ sql.append(" = ");
|
|
|
+ dialect.encodeValue(column, String.class, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ return sql.toString();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates the prepared statement for a query against the relationship table.
|
|
|
+ *
|
|
|
+ * <p>This method is only called when {@link JDBCDataStore#isAssociations()} is true.
|
|
|
+ *
|
|
|
+ * @param table The table of the association
|
|
|
+ * @param column The column of the association
|
|
|
+ */
|
|
|
+ protected PreparedStatement selectRelationshipSQLPS(String table, String column, Connection cx)
|
|
|
+ throws SQLException {
|
|
|
+ PreparedStatementSQLDialect dialect = (PreparedStatementSQLDialect) getSQLDialect();
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("SELECT ");
|
|
|
+ dialect.encodeColumnName(null, "table", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "col", sql);
|
|
|
+
|
|
|
+ sql.append(" FROM ");
|
|
|
+ encodeTableName(FEATURE_RELATIONSHIP_TABLE, sql, null);
|
|
|
+
|
|
|
+ if (table != null) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+
|
|
|
+ dialect.encodeColumnName(null, "table", sql);
|
|
|
+ sql.append(" = ? ");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (column != null) {
|
|
|
+ if (table == null) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+ } else {
|
|
|
+ sql.append(" AND ");
|
|
|
+ }
|
|
|
+
|
|
|
+ dialect.encodeColumnName(null, "col", sql);
|
|
|
+ sql.append(" = ? ");
|
|
|
+ }
|
|
|
+
|
|
|
+ LOGGER.fine(sql.toString());
|
|
|
+ PreparedStatement ps = cx.prepareStatement(sql.toString());
|
|
|
+ if (table != null) {
|
|
|
+ ps.setString(1, table);
|
|
|
+ }
|
|
|
+ if (column != null) {
|
|
|
+ ps.setString(table != null ? 2 : 1, column);
|
|
|
+ }
|
|
|
+ return ps;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates the sql for the association table.
|
|
|
+ *
|
|
|
+ * <p>This method is only called when {@link JDBCDataStore#isAssociations()} is true.
|
|
|
+ *
|
|
|
+ * @param fid The feature id of the association
|
|
|
+ */
|
|
|
+ protected String selectAssociationSQL(String fid) throws SQLException {
|
|
|
+ BasicSQLDialect dialect = (BasicSQLDialect) getSQLDialect();
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("SELECT ");
|
|
|
+ dialect.encodeColumnName(null, "fid", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "rtable", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "rcol", sql);
|
|
|
+ sql.append(", ");
|
|
|
+ dialect.encodeColumnName(null, "rfid", sql);
|
|
|
+
|
|
|
+ sql.append(" FROM ");
|
|
|
+ encodeTableName(FEATURE_ASSOCIATION_TABLE, sql, null);
|
|
|
+
|
|
|
+ if (fid != null) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+
|
|
|
+ dialect.encodeColumnName(null, "fid", sql);
|
|
|
+ sql.append(" = ");
|
|
|
+ dialect.encodeValue(fid, String.class, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ return sql.toString();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates the prepared statement for the association table.
|
|
|
+ *
|
|
|
+ * <p>This method is only called when {@link JDBCDataStore#isAssociations()} is true.
|
|
|
+ *
|
|
|
+ * @param fid The feature id of the association
|
|
|
+ */
|
|
|
+ protected PreparedStatement selectAssociationSQLPS(String fid, Connection cx)
|
|
|
+ throws SQLException {
|
|
|
+ PreparedStatementSQLDialect dialect = (PreparedStatementSQLDialect) getSQLDialect();
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("SELECT ");
|
|
|
+ dialect.encodeColumnName(null, "fid", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "rtable", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "rcol", sql);
|
|
|
+ sql.append(", ");
|
|
|
+ dialect.encodeColumnName(null, "rfid", sql);
|
|
|
+
|
|
|
+ sql.append(" FROM ");
|
|
|
+ encodeTableName(FEATURE_ASSOCIATION_TABLE, sql, null);
|
|
|
+
|
|
|
+ if (fid != null) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+
|
|
|
+ dialect.encodeColumnName(null, "fid", sql);
|
|
|
+ sql.append(" = ?");
|
|
|
+ }
|
|
|
+
|
|
|
+ LOGGER.fine(sql.toString());
|
|
|
+ PreparedStatement ps = cx.prepareStatement(sql.toString());
|
|
|
+ if (fid != null) {
|
|
|
+ ps.setString(1, fid);
|
|
|
+ }
|
|
|
+
|
|
|
+ return ps;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates the sql for a select from the geometry table.
|
|
|
+ *
|
|
|
+ * <p>This method is only called when {@link JDBCDataStore#isAssociations()} is true.
|
|
|
+ *
|
|
|
+ * @param gid The geometry id to select for, may be <code>null</code>
|
|
|
+ */
|
|
|
+ protected String selectGeometrySQL(String gid) throws SQLException {
|
|
|
+
|
|
|
+ BasicSQLDialect dialect = (BasicSQLDialect) getSQLDialect();
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("SELECT ");
|
|
|
+ dialect.encodeColumnName(null, "id", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "name", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "description", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "type", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "geometry", sql);
|
|
|
+ sql.append(" FROM ");
|
|
|
+ encodeTableName(GEOMETRY_TABLE, sql, null);
|
|
|
+
|
|
|
+ if (gid != null) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+
|
|
|
+ dialect.encodeColumnName(null, "id", sql);
|
|
|
+ sql.append(" = ");
|
|
|
+ dialect.encodeValue(gid, String.class, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ return sql.toString();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates the prepared for a select from the geometry table.
|
|
|
+ *
|
|
|
+ * <p>This method is only called when {@link JDBCDataStore#isAssociations()} is true.
|
|
|
+ *
|
|
|
+ * @param gid The geometry id to select for, may be <code>null</code>
|
|
|
+ */
|
|
|
+ protected PreparedStatement selectGeometrySQLPS(String gid, Connection cx) throws SQLException {
|
|
|
+ PreparedStatementSQLDialect dialect = (PreparedStatementSQLDialect) getSQLDialect();
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("SELECT ");
|
|
|
+ dialect.encodeColumnName(null, "id", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "name", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "description", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "type", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "geometry", sql);
|
|
|
+ sql.append(" FROM ");
|
|
|
+ encodeTableName(GEOMETRY_TABLE, sql, null);
|
|
|
+
|
|
|
+ if (gid != null) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+
|
|
|
+ dialect.encodeColumnName(null, "id", sql);
|
|
|
+ sql.append(" = ?");
|
|
|
+ }
|
|
|
+
|
|
|
+ LOGGER.fine(sql.toString());
|
|
|
+ PreparedStatement ps = cx.prepareStatement(sql.toString());
|
|
|
+ if (gid != null) {
|
|
|
+ ps.setString(1, gid);
|
|
|
+ }
|
|
|
+
|
|
|
+ return ps;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates the sql for a select from the multi geometry table.
|
|
|
+ *
|
|
|
+ * <p>This method is only called when {@link JDBCDataStore#isAssociations()} is true.
|
|
|
+ *
|
|
|
+ * @param gid The geometry id to select for, may be <code>null</code>.
|
|
|
+ */
|
|
|
+ protected String selectMultiGeometrySQL(String gid) throws SQLException {
|
|
|
+ BasicSQLDialect dialect = (BasicSQLDialect) getSQLDialect();
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("SELECT ");
|
|
|
+ dialect.encodeColumnName(null, "id", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "mgid", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "ref", sql);
|
|
|
+
|
|
|
+ sql.append(" FROM ");
|
|
|
+ encodeTableName(MULTI_GEOMETRY_TABLE, sql, null);
|
|
|
+
|
|
|
+ if (gid != null) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+
|
|
|
+ dialect.encodeColumnName(null, "id", sql);
|
|
|
+ sql.append(" = ");
|
|
|
+ dialect.encodeValue(gid, String.class, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ return sql.toString();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates the prepared statement for a select from the multi geometry table.
|
|
|
+ *
|
|
|
+ * <p>This method is only called when {@link JDBCDataStore#isAssociations()} is true.
|
|
|
+ *
|
|
|
+ * @param gid The geometry id to select for, may be <code>null</code>.
|
|
|
+ */
|
|
|
+ protected PreparedStatement selectMultiGeometrySQLPS(String gid, Connection cx)
|
|
|
+ throws SQLException {
|
|
|
+ PreparedStatementSQLDialect dialect = (PreparedStatementSQLDialect) getSQLDialect();
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("SELECT ");
|
|
|
+ dialect.encodeColumnName(null, "id", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "mgid", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "ref", sql);
|
|
|
+
|
|
|
+ sql.append(" FROM ");
|
|
|
+ encodeTableName(MULTI_GEOMETRY_TABLE, sql, null);
|
|
|
+
|
|
|
+ if (gid != null) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+
|
|
|
+ dialect.encodeColumnName(null, "id", sql);
|
|
|
+ sql.append(" = ?");
|
|
|
+ }
|
|
|
+
|
|
|
+ LOGGER.fine(sql.toString());
|
|
|
+ PreparedStatement ps = cx.prepareStatement(sql.toString());
|
|
|
+ if (gid != null) {
|
|
|
+ ps.setString(1, gid);
|
|
|
+ }
|
|
|
+
|
|
|
+ return ps;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates the sql for the geometry association table.
|
|
|
+ *
|
|
|
+ * <p>This method is only called when {@link JDBCDataStore#isAssociations()} is true.
|
|
|
+ */
|
|
|
+ protected String createGeometryAssociationTableSQL(Connection cx) throws SQLException {
|
|
|
+ String[] sqlTypeNames =
|
|
|
+ getSQLTypeNames(
|
|
|
+ descriptors(String.class, String.class, String.class, Boolean.class), cx);
|
|
|
+ String[] columnNames = {"fid", "gname", "gid", "ref"};
|
|
|
+
|
|
|
+ return createTableSQL(
|
|
|
+ GEOMETRY_ASSOCIATION_TABLE, columnNames, sqlTypeNames, null, null, null);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates the sql for a select from the geometry association table.
|
|
|
+ *
|
|
|
+ * <p>
|
|
|
+ *
|
|
|
+ * @param fid The fid to select for, may be <code>null</code>
|
|
|
+ * @param gid The geometry id to select for, may be <code>null</code>
|
|
|
+ * @param gname The geometry name to select for, may be <code>null</code>
|
|
|
+ */
|
|
|
+ protected String selectGeometryAssociationSQL(String fid, String gid, String gname)
|
|
|
+ throws SQLException {
|
|
|
+ BasicSQLDialect dialect = (BasicSQLDialect) getSQLDialect();
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("SELECT ");
|
|
|
+ dialect.encodeColumnName(null, "fid", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "gid", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "gname", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "ref", sql);
|
|
|
+
|
|
|
+ sql.append(" FROM ");
|
|
|
+ encodeTableName(GEOMETRY_ASSOCIATION_TABLE, sql, null);
|
|
|
+
|
|
|
+ if (fid != null) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+ dialect.encodeColumnName(null, "fid", sql);
|
|
|
+ sql.append(" = ");
|
|
|
+ dialect.encodeValue(fid, String.class, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (gid != null) {
|
|
|
+ if (fid == null) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+ } else {
|
|
|
+ sql.append(" AND ");
|
|
|
+ }
|
|
|
+
|
|
|
+ dialect.encodeColumnName(null, "gid", sql);
|
|
|
+ sql.append(" = ");
|
|
|
+ dialect.encodeValue(gid, String.class, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (gname != null) {
|
|
|
+ if ((fid == null) && (gid == null)) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+ } else {
|
|
|
+ sql.append(" AND ");
|
|
|
+ }
|
|
|
+
|
|
|
+ dialect.encodeColumnName(null, "gname", sql);
|
|
|
+ sql.append(" = ");
|
|
|
+ dialect.encodeValue(gname, String.class, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ return sql.toString();
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Creates the prepared statement for a select from the geometry association table.
|
|
|
+ *
|
|
|
+ * <p>
|
|
|
+ *
|
|
|
+ * @param fid The fid to select for, may be <code>null</code>
|
|
|
+ * @param gid The geometry id to select for, may be <code>null</code>
|
|
|
+ * @param gname The geometry name to select for, may be <code>null</code>
|
|
|
+ */
|
|
|
+ protected PreparedStatement selectGeometryAssociationSQLPS(
|
|
|
+ String fid, String gid, String gname, Connection cx) throws SQLException {
|
|
|
+ PreparedStatementSQLDialect dialect = (PreparedStatementSQLDialect) getSQLDialect();
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("SELECT ");
|
|
|
+ dialect.encodeColumnName(null, "fid", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "gid", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "gname", sql);
|
|
|
+ sql.append(",");
|
|
|
+ dialect.encodeColumnName(null, "ref", sql);
|
|
|
+
|
|
|
+ sql.append(" FROM ");
|
|
|
+ encodeTableName(GEOMETRY_ASSOCIATION_TABLE, sql, null);
|
|
|
+
|
|
|
+ if (fid != null) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+ dialect.encodeColumnName(null, "fid", sql);
|
|
|
+ sql.append(" = ? ");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (gid != null) {
|
|
|
+ if (fid == null) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+ } else {
|
|
|
+ sql.append(" AND ");
|
|
|
+ }
|
|
|
+
|
|
|
+ dialect.encodeColumnName(null, "gid", sql);
|
|
|
+ sql.append(" = ? ");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (gname != null) {
|
|
|
+ if ((fid == null) && (gid == null)) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+ } else {
|
|
|
+ sql.append(" AND ");
|
|
|
+ }
|
|
|
+
|
|
|
+ dialect.encodeColumnName(null, "gname", sql);
|
|
|
+ sql.append(" = ?");
|
|
|
+ }
|
|
|
+
|
|
|
+ LOGGER.fine(sql.toString());
|
|
|
+ PreparedStatement ps = cx.prepareStatement(sql.toString());
|
|
|
+ if (fid != null) {
|
|
|
+ ps.setString(1, fid);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (gid != null) {
|
|
|
+ ps.setString(fid != null ? 2 : 1, gid);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (gname != null) {
|
|
|
+ ps.setString(fid != null ? (gid != null ? 3 : 2) : (gid != null ? 2 : 1), gname);
|
|
|
+ }
|
|
|
+
|
|
|
+ return ps;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Helper method for building a 'CREATE TABLE' sql statement. */
|
|
|
+ private String createTableSQL(
|
|
|
+ String tableName,
|
|
|
+ String[] columnNames,
|
|
|
+ String[] sqlTypeNames,
|
|
|
+ boolean[] nillable,
|
|
|
+ String pkeyColumn,
|
|
|
+ SimpleFeatureType featureType)
|
|
|
+ throws SQLException {
|
|
|
+ // build the create table sql
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ dialect.encodeCreateTable(sql);
|
|
|
+
|
|
|
+ encodeTableName(tableName, sql, null);
|
|
|
+ sql.append(" ( ");
|
|
|
+
|
|
|
+ // primary key column
|
|
|
+ if (pkeyColumn != null) {
|
|
|
+ dialect.encodePrimaryKey(pkeyColumn, sql);
|
|
|
+ sql.append(", ");
|
|
|
+ }
|
|
|
+
|
|
|
+ // normal attributes
|
|
|
+ for (int i = 0; i < columnNames.length; i++) {
|
|
|
+ // the column name
|
|
|
+ dialect.encodeColumnName(null, columnNames[i], sql);
|
|
|
+ sql.append(" ");
|
|
|
+
|
|
|
+ // some sql dialects require varchars to have an
|
|
|
+ // associated size with them
|
|
|
+ int length = -1;
|
|
|
+ if (sqlTypeNames[i].toUpperCase().startsWith("VARCHAR")) {
|
|
|
+ if (featureType != null) {
|
|
|
+ AttributeDescriptor att = featureType.getDescriptor(columnNames[i]);
|
|
|
+ length = findVarcharColumnLength(att);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // only apply a length if one exists (i.e. to applicable varchars)
|
|
|
+ if (length == -1) {
|
|
|
+ dialect.encodeColumnType(sqlTypeNames[i], sql);
|
|
|
+ } else {
|
|
|
+ dialect.encodeColumnType(sqlTypeNames[i] + "(" + length + ")", sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ // nullable
|
|
|
+ if (nillable != null && !nillable[i]) {
|
|
|
+ sql.append(" NOT NULL ");
|
|
|
+ }
|
|
|
+
|
|
|
+ // delegate to dialect to encode column postamble
|
|
|
+ if (featureType != null) {
|
|
|
+ AttributeDescriptor att = featureType.getDescriptor(columnNames[i]);
|
|
|
+ dialect.encodePostColumnCreateTable(att, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ // sql.append(sqlTypeNames[i]);
|
|
|
+ if (i < (sqlTypeNames.length - 1)) {
|
|
|
+ sql.append(", ");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ sql.append(" ) ");
|
|
|
+
|
|
|
+ // encode anything post create table
|
|
|
+ dialect.encodePostCreateTable(tableName, sql);
|
|
|
+
|
|
|
+ return sql.toString();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Searches the attribute descriptor restrictions in an attempt to determine the length of the
|
|
|
+ * specified varchar column.
|
|
|
+ */
|
|
|
+ private Integer findVarcharColumnLength(AttributeDescriptor att) {
|
|
|
+ for (Filter r : att.getType().getRestrictions()) {
|
|
|
+ if (r instanceof PropertyIsLessThanOrEqualTo) {
|
|
|
+ PropertyIsLessThanOrEqualTo c = (PropertyIsLessThanOrEqualTo) r;
|
|
|
+ if (c.getExpression1() instanceof Function
|
|
|
+ && ((Function) c.getExpression1())
|
|
|
+ .getName()
|
|
|
+ .toLowerCase()
|
|
|
+ .endsWith("length")) {
|
|
|
+ if (c.getExpression2() instanceof Literal) {
|
|
|
+ Integer length = c.getExpression2().evaluate(null, Integer.class);
|
|
|
+ if (length != null) {
|
|
|
+ return length;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return dialect.getDefaultVarcharSize();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Helper method for determining what the sql type names are for a set of classes.
|
|
|
+ *
|
|
|
+ * <p>This method uses a combination of dialect mappings and database metadata to determine
|
|
|
+ * which sql types map to the specified classes.
|
|
|
+ */
|
|
|
+ private String[] getSQLTypeNames(List<AttributeDescriptor> descriptors, Connection cx)
|
|
|
+ throws SQLException {
|
|
|
+ // figure out what the sql types are corresponding to the feature type
|
|
|
+ // attributes
|
|
|
+ int[] sqlTypes = new int[descriptors.size()];
|
|
|
+ String[] sqlTypeNames = new String[sqlTypes.length];
|
|
|
+
|
|
|
+ for (int i = 0; i < descriptors.size(); i++) {
|
|
|
+ AttributeDescriptor ad = descriptors.get(i);
|
|
|
+ Class clazz = ad.getType().getBinding();
|
|
|
+ Integer sqlType = dialect.getSQLType(ad);
|
|
|
+
|
|
|
+ if (sqlType == null) {
|
|
|
+ sqlType = getMapping(clazz);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (sqlType == null) {
|
|
|
+ LOGGER.warning(
|
|
|
+ "No sql type mapping for: " + ad.getLocalName() + " of type " + clazz);
|
|
|
+ sqlType = Types.OTHER;
|
|
|
+ }
|
|
|
+
|
|
|
+ sqlTypes[i] = sqlType;
|
|
|
+
|
|
|
+ // if this a geometric type, get the name from the dialect
|
|
|
+ // if ( attributeType instanceof GeometryDescriptor ) {
|
|
|
+ if (Geometry.class.isAssignableFrom(clazz)) {
|
|
|
+ String sqlTypeName = dialect.getGeometryTypeName(sqlType);
|
|
|
+
|
|
|
+ if (sqlTypeName != null) {
|
|
|
+ sqlTypeNames[i] = sqlTypeName;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // check types previously read from DB
|
|
|
+ String sqlTypeDBName = getDBsqlTypesCache().get(sqlType);
|
|
|
+ if (sqlTypeDBName != null) {
|
|
|
+ sqlTypeNames[i] = sqlTypeDBName;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // GEOT-6347 if all sql type names have been found in dialect dont
|
|
|
+ // go to database
|
|
|
+ boolean allTypesFound = !ArrayUtils.contains(sqlTypeNames, null);
|
|
|
+ if (!allTypesFound) {
|
|
|
+ LOGGER.log(Level.WARNING, "Fetching fields from Database");
|
|
|
+ // figure out the type names that correspond to the sql types from
|
|
|
+ // the database metadata
|
|
|
+ DatabaseMetaData metaData = cx.getMetaData();
|
|
|
+
|
|
|
+ /*
|
|
|
+ * <LI><B>TYPE_NAME</B> String => Type name
|
|
|
+ * <LI><B>DATA_TYPE</B> int => SQL data type from java.sql.Types
|
|
|
+ * <LI><B>PRECISION</B> int => maximum precision
|
|
|
+ * <LI><B>LITERAL_PREFIX</B> String => prefix used to quote a literal
|
|
|
+ * (may be <code>null</code>)
|
|
|
+ * <LI><B>LITERAL_SUFFIX</B> String => suffix used to quote a literal
|
|
|
+ (may be <code>null</code>)
|
|
|
+ * <LI><B>CREATE_PARAMS</B> String => parameters used in creating
|
|
|
+ * the type (may be <code>null</code>)
|
|
|
+ * <LI><B>NULLABLE</B> short => can you use NULL for this type.
|
|
|
+ * <UL>
|
|
|
+ * <LI> typeNoNulls - does not allow NULL values
|
|
|
+ * <LI> typeNullable - allows NULL values
|
|
|
+ * <LI> typeNullableUnknown - nullability unknown
|
|
|
+ * </UL>
|
|
|
+ * <LI><B>CASE_SENSITIVE</B> boolean=> is it case sensitive.
|
|
|
+ * <LI><B>SEARCHABLE</B> short => can you use "WHERE" based on this type:
|
|
|
+ * <UL>
|
|
|
+ * <LI> typePredNone - No support
|
|
|
+ * <LI> typePredChar - Only supported with WHERE .. LIKE
|
|
|
+ * <LI> typePredBasic - Supported except for WHERE .. LIKE
|
|
|
+ * <LI> typeSearchable - Supported for all WHERE ..
|
|
|
+ * </UL>
|
|
|
+ * <LI><B>UNSIGNED_ATTRIBUTE</B> boolean => is it unsigned.
|
|
|
+ * <LI><B>FIXED_PREC_SCALE</B> boolean => can it be a money value.
|
|
|
+ * <LI><B>AUTO_INCREMENT</B> boolean => can it be used for an
|
|
|
+ * auto-increment value.
|
|
|
+ * <LI><B>LOCAL_TYPE_NAME</B> String => localized version of type name
|
|
|
+ * (may be <code>null</code>)
|
|
|
+ * <LI><B>MINIMUM_SCALE</B> short => minimum scale supported
|
|
|
+ * <LI><B>MAXIMUM_SCALE</B> short => maximum scale supported
|
|
|
+ * <LI><B>SQL_DATA_TYPE</B> int => unused
|
|
|
+ * <LI><B>SQL_DATETIME_SUB</B> int => unused
|
|
|
+ * <LI><B>NUM_PREC_RADIX</B> int => usually 2 or 10
|
|
|
+ */
|
|
|
+ ResultSet types = metaData.getTypeInfo();
|
|
|
+
|
|
|
+ try {
|
|
|
+ while (types.next()) {
|
|
|
+ int sqlType = types.getInt("DATA_TYPE");
|
|
|
+ String sqlTypeName = types.getString("TYPE_NAME");
|
|
|
+
|
|
|
+ for (int i = 0; i < sqlTypes.length; i++) {
|
|
|
+ // check if we already have the type name from the dialect
|
|
|
+ if (sqlTypeNames[i] != null) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (sqlType == sqlTypes[i]) {
|
|
|
+ sqlTypeNames[i] = sqlTypeName;
|
|
|
+ // GEOT-6347
|
|
|
+ // cache the sqlType which required going to database for sql types
|
|
|
+ getDBsqlTypesCache().putIfAbsent(sqlType, sqlTypeName);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } finally {
|
|
|
+ closeSafe(types);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // apply the overrides specified by the dialect
|
|
|
+ Map<Integer, String> overrides = getSqlTypeToSqlTypeNameOverrides();
|
|
|
+ for (int i = 0; i < sqlTypes.length; i++) {
|
|
|
+ String override = overrides.get(sqlTypes[i]);
|
|
|
+ if (override != null) sqlTypeNames[i] = override;
|
|
|
+ }
|
|
|
+
|
|
|
+ return sqlTypeNames;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Generates a 'SELECT p1, p2, ... FROM ... WHERE ...' statement.
|
|
|
+ *
|
|
|
+ * @param featureType the feature type that the query must return (may contain less attributes
|
|
|
+ * than the native one)
|
|
|
+ * @param query the query to be run. The type name and property will be ignored, as they are
|
|
|
+ * supposed to have been already embedded into the provided feature type
|
|
|
+ */
|
|
|
+ public String selectSQL(SimpleFeatureType featureType, Query query)
|
|
|
+ throws IOException, SQLException {
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("SELECT ");
|
|
|
+
|
|
|
+ // column names
|
|
|
+ selectColumns(featureType, null, query, sql);
|
|
|
+ sql.setLength(sql.length() - 1);
|
|
|
+ dialect.encodePostSelect(featureType, sql);
|
|
|
+
|
|
|
+ // from
|
|
|
+ sql.append(" FROM ");
|
|
|
+ encodeTableName(featureType.getTypeName(), sql, setKeepWhereClausePlaceHolderHint(query));
|
|
|
+
|
|
|
+ // filtering
|
|
|
+ Filter filter = query.getFilter();
|
|
|
+ if (filter != null && !Filter.INCLUDE.equals(filter)) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+ // encode filter
|
|
|
+ filter(featureType, filter, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ // sorting
|
|
|
+ sort(featureType, query.getSortBy(), null, sql);
|
|
|
+
|
|
|
+ // encode limit/offset, if necessary
|
|
|
+ applyLimitOffset(sql, query.getStartIndex(), query.getMaxFeatures());
|
|
|
+
|
|
|
+ // add search hints if the dialect supports them
|
|
|
+ applySearchHints(featureType, query, sql);
|
|
|
+
|
|
|
+ return sql.toString();
|
|
|
+ }
|
|
|
+
|
|
|
+ private void applySearchHints(SimpleFeatureType featureType, Query query, StringBuffer sql) {
|
|
|
+ // we can apply search hints only on real tables
|
|
|
+ if (virtualTables.containsKey(featureType.getTypeName())) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ dialect.handleSelectHints(sql, featureType, query);
|
|
|
+ }
|
|
|
+
|
|
|
+ protected String selectJoinSQL(SimpleFeatureType featureType, JoinInfo join, Query query)
|
|
|
+ throws IOException, SQLException {
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("SELECT ");
|
|
|
+
|
|
|
+ // column names
|
|
|
+ selectColumns(featureType, join.getPrimaryAlias(), query, sql);
|
|
|
+
|
|
|
+ // joined columns
|
|
|
+ for (JoinPart part : join.getParts()) {
|
|
|
+ selectColumns(part.getQueryFeatureType(), part.getAlias(), query, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ sql.setLength(sql.length() - 1);
|
|
|
+ dialect.encodePostSelect(featureType, sql);
|
|
|
+
|
|
|
+ // from
|
|
|
+ sql.append(" FROM ");
|
|
|
+
|
|
|
+ // join clauses
|
|
|
+ encodeTableJoin(featureType, join, query, sql);
|
|
|
+
|
|
|
+ // filtering
|
|
|
+ encodeWhereJoin(featureType, join, sql);
|
|
|
+
|
|
|
+ // TODO: sorting
|
|
|
+ sort(featureType, query.getSortBy(), join.getPrimaryAlias(), sql);
|
|
|
+
|
|
|
+ // finally encode limit/offset, if necessary
|
|
|
+ applyLimitOffset(sql, query.getStartIndex(), query.getMaxFeatures());
|
|
|
+
|
|
|
+ return sql.toString();
|
|
|
+ }
|
|
|
+
|
|
|
+ public void selectColumns(SimpleFeatureType featureType, String prefix, Query query, StringBuffer sql)
|
|
|
+ throws IOException {
|
|
|
+
|
|
|
+ // primary key
|
|
|
+ PrimaryKey key = null;
|
|
|
+ try {
|
|
|
+ key = getPrimaryKey(featureType);
|
|
|
+ } catch (IOException e) {
|
|
|
+ throw new RuntimeException(e);
|
|
|
+ }
|
|
|
+ Set<String> pkColumnNames = getColumnNames(key);
|
|
|
+
|
|
|
+ // we need to add the primary key columns only if they are not already exposed
|
|
|
+ for (PrimaryKeyColumn col : key.getColumns()) {
|
|
|
+ dialect.encodeColumnName(prefix, col.getName(), sql);
|
|
|
+ if (prefix != null) {
|
|
|
+ // if a prefix is specified means we are joining so use a prefix to avoid clashing
|
|
|
+ // with primary key columsn with the same name from other tables in the join
|
|
|
+ dialect.encodeColumnAlias(prefix + "_" + col.getName(), sql);
|
|
|
+ }
|
|
|
+ sql.append(",");
|
|
|
+ }
|
|
|
+
|
|
|
+ // other columns
|
|
|
+ for (AttributeDescriptor att : featureType.getAttributeDescriptors()) {
|
|
|
+ String columnName = att.getLocalName();
|
|
|
+ // skip the eventually exposed pk column values
|
|
|
+ if (pkColumnNames.contains(columnName)) continue;
|
|
|
+
|
|
|
+ String alias = null;
|
|
|
+ if (att.getUserData().containsKey(JDBC_COLUMN_ALIAS)) {
|
|
|
+ alias = (String) att.getUserData().get(JDBC_COLUMN_ALIAS);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (att instanceof GeometryDescriptor) {
|
|
|
+ // encode as geometry
|
|
|
+ encodeGeometryColumn((GeometryDescriptor) att, prefix, sql, query.getHints());
|
|
|
+
|
|
|
+ if (alias == null) {
|
|
|
+ // alias it to be the name of the original geometry
|
|
|
+ alias = columnName;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ dialect.encodeColumnName(prefix, columnName, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (alias != null) {
|
|
|
+ dialect.encodeColumnAlias(alias, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ sql.append(",");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ FilterToSQL filter(SimpleFeatureType featureType, Filter filter, StringBuffer sql)
|
|
|
+ throws IOException {
|
|
|
+ SimpleFeatureType fullSchema = getSchema(featureType.getTypeName());
|
|
|
+ FilterToSQL toSQL = getFilterToSQL(fullSchema);
|
|
|
+ return filter(featureType, filter, sql, toSQL);
|
|
|
+ }
|
|
|
+
|
|
|
+ FilterToSQL filter(
|
|
|
+ SimpleFeatureType featureType, Filter filter, StringBuffer sql, FilterToSQL toSQL)
|
|
|
+ throws IOException {
|
|
|
+
|
|
|
+ try {
|
|
|
+ // grab the full feature type, as we might be encoding a filter
|
|
|
+ // that uses attributes that aren't returned in the results
|
|
|
+ toSQL.setInline(true);
|
|
|
+ String filterSql = toSQL.encodeToString(filter);
|
|
|
+ int whereClauseIndex = sql.indexOf(WHERE_CLAUSE_PLACE_HOLDER);
|
|
|
+ if (whereClauseIndex != -1) {
|
|
|
+ sql.replace(
|
|
|
+ whereClauseIndex,
|
|
|
+ whereClauseIndex + WHERE_CLAUSE_PLACE_HOLDER_LENGTH,
|
|
|
+ "AND " + filterSql);
|
|
|
+ sql.append("1 = 1");
|
|
|
+ } else {
|
|
|
+ sql.append(filterSql);
|
|
|
+ }
|
|
|
+ return toSQL;
|
|
|
+ } catch (FilterToSQLException e) {
|
|
|
+ throw new RuntimeException(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private FilterToSQL getFilterToSQL(SimpleFeatureType fullSchema) {
|
|
|
+ return dialect instanceof PreparedStatementSQLDialect
|
|
|
+ ? createPreparedFilterToSQL(fullSchema)
|
|
|
+ : createFilterToSQL(fullSchema);
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Encodes the sort-by portion of an sql query */
|
|
|
+ void sort(SimpleFeatureType featureType, SortBy[] sort, String prefix, StringBuffer sql)
|
|
|
+ throws IOException {
|
|
|
+ if ((sort != null) && (sort.length > 0)) {
|
|
|
+ PrimaryKey key = getPrimaryKey(featureType);
|
|
|
+ sql.append(" ORDER BY ");
|
|
|
+
|
|
|
+ for (SortBy sortBy : sort) {
|
|
|
+ String order;
|
|
|
+ if (sortBy.getSortOrder() == SortOrder.DESCENDING) {
|
|
|
+ order = " DESC";
|
|
|
+ } else {
|
|
|
+ order = " ASC";
|
|
|
+ }
|
|
|
+
|
|
|
+ if (SortBy.NATURAL_ORDER.equals(sortBy) || SortBy.REVERSE_ORDER.equals(sortBy)) {
|
|
|
+ if (key instanceof NullPrimaryKey)
|
|
|
+ throw new IOException(
|
|
|
+ "Cannot do natural order without a primary key, please add it or "
|
|
|
+ + "specify a manual sort over existing attributes");
|
|
|
+
|
|
|
+ for (PrimaryKeyColumn col : key.getColumns()) {
|
|
|
+ dialect.encodeColumnName(prefix, col.getName(), sql);
|
|
|
+ sql.append(order);
|
|
|
+ sql.append(",");
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ dialect.encodeColumnName(
|
|
|
+ prefix, getPropertyName(featureType, sortBy.getPropertyName()), sql);
|
|
|
+ sql.append(order);
|
|
|
+ sql.append(",");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ sql.setLength(sql.length() - 1);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Generates a 'SELECT p1, p2, ... FROM ... WHERE ...' prepared statement.
|
|
|
+ *
|
|
|
+ * @param featureType the feature type that the query must return (may contain less attributes
|
|
|
+ * than the native one)
|
|
|
+ * @param query the query to be run. The type name and property will be ignored, as they are
|
|
|
+ * supposed to have been already embedded into the provided feature type
|
|
|
+ * @param cx The database connection to be used to create the prepared statement
|
|
|
+ */
|
|
|
+ protected PreparedStatement selectSQLPS(
|
|
|
+ SimpleFeatureType featureType, Query query, Connection cx)
|
|
|
+ throws SQLException, IOException {
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("SELECT ");
|
|
|
+
|
|
|
+ // column names
|
|
|
+ selectColumns(featureType, null, query, sql);
|
|
|
+ sql.setLength(sql.length() - 1);
|
|
|
+ dialect.encodePostSelect(featureType, sql);
|
|
|
+
|
|
|
+ sql.append(" FROM ");
|
|
|
+ encodeTableName(featureType.getTypeName(), sql, setKeepWhereClausePlaceHolderHint(query));
|
|
|
+
|
|
|
+ // filtering
|
|
|
+ PreparedFilterToSQL toSQL = null;
|
|
|
+ Filter filter = query.getFilter();
|
|
|
+ if (filter != null && !Filter.INCLUDE.equals(filter)) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+
|
|
|
+ // encode filter
|
|
|
+ toSQL = (PreparedFilterToSQL) filter(featureType, filter, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ // sorting
|
|
|
+ sort(featureType, query.getSortBy(), null, sql);
|
|
|
+
|
|
|
+ // finally encode limit/offset, if necessary
|
|
|
+ applyLimitOffset(sql, query.getStartIndex(), query.getMaxFeatures());
|
|
|
+
|
|
|
+ // add search hints if the dialect supports them
|
|
|
+ applySearchHints(featureType, query, sql);
|
|
|
+
|
|
|
+ LOGGER.fine(sql.toString());
|
|
|
+ PreparedStatement ps =
|
|
|
+ cx.prepareStatement(
|
|
|
+ sql.toString(), ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
|
|
|
+ ps.setFetchSize(fetchSize);
|
|
|
+
|
|
|
+ if (toSQL != null) {
|
|
|
+ setPreparedFilterValues(ps, toSQL, 0, cx);
|
|
|
+ }
|
|
|
+
|
|
|
+ return ps;
|
|
|
+ }
|
|
|
+
|
|
|
+ protected PreparedStatement selectJoinSQLPS(
|
|
|
+ SimpleFeatureType featureType, JoinInfo join, Query query, Connection cx)
|
|
|
+ throws SQLException, IOException {
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("SELECT ");
|
|
|
+
|
|
|
+ selectColumns(featureType, join.getPrimaryAlias(), query, sql);
|
|
|
+
|
|
|
+ // joined columns
|
|
|
+ for (JoinPart part : join.getParts()) {
|
|
|
+ selectColumns(part.getQueryFeatureType(), part.getAlias(), query, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ sql.setLength(sql.length() - 1);
|
|
|
+ dialect.encodePostSelect(featureType, sql);
|
|
|
+
|
|
|
+ sql.append(" FROM ");
|
|
|
+
|
|
|
+ // join clauses
|
|
|
+ encodeTableJoin(featureType, join, query, sql);
|
|
|
+
|
|
|
+ // filtering
|
|
|
+ List<FilterToSQL> toSQLs = encodeWhereJoin(featureType, join, sql);
|
|
|
+
|
|
|
+ // sorting
|
|
|
+ sort(featureType, query.getSortBy(), join.getPrimaryAlias(), sql);
|
|
|
+
|
|
|
+ // finally encode limit/offset, if necessary
|
|
|
+ applyLimitOffset(sql, query.getStartIndex(), query.getMaxFeatures());
|
|
|
+
|
|
|
+ LOGGER.fine(sql.toString());
|
|
|
+ PreparedStatement ps =
|
|
|
+ cx.prepareStatement(
|
|
|
+ sql.toString(), ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
|
|
|
+ ps.setFetchSize(fetchSize);
|
|
|
+
|
|
|
+ setPreparedFilterValues(ps, toSQLs, cx);
|
|
|
+
|
|
|
+ return ps;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Helper method for setting the values of the WHERE class of a prepared statement from a list
|
|
|
+ * of PreparedFilterToSQL.
|
|
|
+ */
|
|
|
+ protected void setPreparedFilterValues(
|
|
|
+ PreparedStatement ps, List<FilterToSQL> toSQLs, Connection cx) throws SQLException {
|
|
|
+ int offset = 0;
|
|
|
+ for (FilterToSQL fts : toSQLs) {
|
|
|
+ PreparedFilterToSQL toSQL = (PreparedFilterToSQL) fts;
|
|
|
+ setPreparedFilterValues(ps, toSQL, offset, cx);
|
|
|
+ offset += toSQL.getLiteralValues().size();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Helper method for setting the values of the WHERE class of a prepared statement. */
|
|
|
+ public void setPreparedFilterValues(
|
|
|
+ PreparedStatement ps, PreparedFilterToSQL toSQL, int offset, Connection cx)
|
|
|
+ throws SQLException {
|
|
|
+ PreparedStatementSQLDialect dialect = (PreparedStatementSQLDialect) getSQLDialect();
|
|
|
+
|
|
|
+ for (int i = 0; i < toSQL.getLiteralValues().size(); i++) {
|
|
|
+ Object value = toSQL.getLiteralValues().get(i);
|
|
|
+ Class binding = toSQL.getLiteralTypes().get(i);
|
|
|
+ Integer srid = toSQL.getSRIDs().get(i);
|
|
|
+ Integer dimension = toSQL.getDimensions().get(i);
|
|
|
+ AttributeDescriptor ad = toSQL.getDescriptors().get(i);
|
|
|
+ if (srid == null) {
|
|
|
+ srid = -1;
|
|
|
+ }
|
|
|
+ if (dimension == null) {
|
|
|
+ dimension = 2;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (binding != null && Geometry.class.isAssignableFrom(binding)) {
|
|
|
+ dialect.setGeometryValue(
|
|
|
+ (Geometry) value, dimension, srid, binding, ps, offset + i + 1);
|
|
|
+ } else if (ad != null && this.dialect.isArray(ad)) {
|
|
|
+ dialect.setArrayValue(value, ad, ps, offset + i + 1, cx);
|
|
|
+ } else {
|
|
|
+ dialect.setValue(value, binding, ps, offset + i + 1, cx);
|
|
|
+ }
|
|
|
+ if (LOGGER.isLoggable(Level.FINE)) {
|
|
|
+ LOGGER.fine((i + 1) + " = " + value);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Helper method for executing a property name against a feature type.
|
|
|
+ *
|
|
|
+ * <p>This method will fall back on {@link PropertyName#getPropertyName()} if it does not
|
|
|
+ * evaulate against the feature type.
|
|
|
+ */
|
|
|
+ protected String getPropertyName(SimpleFeatureType featureType, PropertyName propertyName) {
|
|
|
+ AttributeDescriptor att = (AttributeDescriptor) propertyName.evaluate(featureType);
|
|
|
+
|
|
|
+ if (att != null) {
|
|
|
+ return att.getLocalName();
|
|
|
+ }
|
|
|
+
|
|
|
+ return propertyName.getPropertyName();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Generates a 'SELECT' sql statement which selects bounds.
|
|
|
+ *
|
|
|
+ * @param featureType The feature type / table.
|
|
|
+ * @param query Specifies which features are to be used for the bounds computation (and in
|
|
|
+ * particular uses filter, start index and max features)
|
|
|
+ */
|
|
|
+ protected String selectBoundsSQL(SimpleFeatureType featureType, Query query)
|
|
|
+ throws SQLException {
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+
|
|
|
+ boolean offsetLimit = checkLimitOffset(query.getStartIndex(), query.getMaxFeatures());
|
|
|
+ if (offsetLimit) {
|
|
|
+ // envelopes are aggregates, just like count, so we must first isolate
|
|
|
+ // the rows against which the aggregate will work in a subquery
|
|
|
+ sql.append(" SELECT *");
|
|
|
+ } else {
|
|
|
+ sql.append("SELECT ");
|
|
|
+ buildEnvelopeAggregates(featureType, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ sql.append(" FROM ");
|
|
|
+ encodeTableName(featureType.getTypeName(), sql, setKeepWhereClausePlaceHolderHint(query));
|
|
|
+
|
|
|
+ Filter filter = query.getFilter();
|
|
|
+ if (filter != null && !Filter.INCLUDE.equals(filter)) {
|
|
|
+ // encode filter
|
|
|
+ try {
|
|
|
+ FilterToSQL toSQL = createFilterToSQL(featureType);
|
|
|
+ sql.append(" ").append(toSQL.encodeToString(filter));
|
|
|
+ } catch (FilterToSQLException e) {
|
|
|
+ throw new RuntimeException(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // finally encode limit/offset, if necessary
|
|
|
+ if (offsetLimit) {
|
|
|
+ applyLimitOffset(sql, query.getStartIndex(), query.getMaxFeatures());
|
|
|
+ // build the prologue
|
|
|
+ StringBuffer sb = new StringBuffer();
|
|
|
+ sb.append("SELECT ");
|
|
|
+ buildEnvelopeAggregates(featureType, sb);
|
|
|
+ sb.append("FROM (");
|
|
|
+ // wrap the existing query
|
|
|
+ sql.insert(0, sb.toString());
|
|
|
+ sql.append(")");
|
|
|
+ dialect.encodeTableAlias("GT2_BOUNDS_", sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ // add search hints if the dialect supports them
|
|
|
+ applySearchHints(featureType, query, sql);
|
|
|
+
|
|
|
+ return sql.toString();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Generates a 'SELECT' prepared statement which selects bounds.
|
|
|
+ *
|
|
|
+ * @param featureType The feature type / table.
|
|
|
+ * @param query Specifies which features are to be used for the bounds computation (and in
|
|
|
+ * particular uses filter, start index and max features)
|
|
|
+ * @param cx A database connection.
|
|
|
+ */
|
|
|
+ protected PreparedStatement selectBoundsSQLPS(
|
|
|
+ SimpleFeatureType featureType, Query query, Connection cx) throws SQLException {
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+
|
|
|
+ boolean offsetLimit = checkLimitOffset(query.getStartIndex(), query.getMaxFeatures());
|
|
|
+ if (offsetLimit) {
|
|
|
+ // envelopes are aggregates, just like count, so we must first isolate
|
|
|
+ // the rows against which the aggregate will work in a subquery
|
|
|
+ sql.append(" SELECT *");
|
|
|
+ } else {
|
|
|
+ sql.append("SELECT ");
|
|
|
+ buildEnvelopeAggregates(featureType, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ sql.append(" FROM ");
|
|
|
+ encodeTableName(featureType.getTypeName(), sql, setKeepWhereClausePlaceHolderHint(query));
|
|
|
+
|
|
|
+ // encode the filter
|
|
|
+ PreparedFilterToSQL toSQL = null;
|
|
|
+ Filter filter = query.getFilter();
|
|
|
+ if (filter != null && !Filter.INCLUDE.equals(filter)) {
|
|
|
+ // encode filter
|
|
|
+ try {
|
|
|
+ toSQL = createPreparedFilterToSQL(featureType);
|
|
|
+ int whereClauseIndex = sql.indexOf(WHERE_CLAUSE_PLACE_HOLDER);
|
|
|
+ if (whereClauseIndex != -1) {
|
|
|
+ toSQL.setInline(true);
|
|
|
+ sql.replace(
|
|
|
+ whereClauseIndex,
|
|
|
+ whereClauseIndex + WHERE_CLAUSE_PLACE_HOLDER_LENGTH,
|
|
|
+ "AND " + toSQL.encodeToString(filter));
|
|
|
+ toSQL.setInline(false);
|
|
|
+ } else {
|
|
|
+ sql.append(" ").append(toSQL.encodeToString(filter));
|
|
|
+ }
|
|
|
+ } catch (FilterToSQLException e) {
|
|
|
+ throw new RuntimeException(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // finally encode limit/offset, if necessary
|
|
|
+ if (offsetLimit) {
|
|
|
+ applyLimitOffset(sql, query.getStartIndex(), query.getMaxFeatures());
|
|
|
+ // build the prologue
|
|
|
+ StringBuffer sb = new StringBuffer();
|
|
|
+ sb.append("SELECT ");
|
|
|
+ buildEnvelopeAggregates(featureType, sb);
|
|
|
+ sb.append("FROM (");
|
|
|
+ // wrap the existing query
|
|
|
+ sql.insert(0, sb.toString());
|
|
|
+ sql.append(")");
|
|
|
+ dialect.encodeTableAlias("GT2_BOUNDS_", sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ // add search hints if the dialect supports them
|
|
|
+ applySearchHints(featureType, query, sql);
|
|
|
+
|
|
|
+ LOGGER.fine(sql.toString());
|
|
|
+ PreparedStatement ps = cx.prepareStatement(sql.toString());
|
|
|
+
|
|
|
+ if (toSQL != null) {
|
|
|
+ setPreparedFilterValues(ps, toSQL, 0, cx);
|
|
|
+ }
|
|
|
+
|
|
|
+ return ps;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Builds a list of the aggregate function calls necesary to compute each geometry column bounds
|
|
|
+ */
|
|
|
+ void buildEnvelopeAggregates(SimpleFeatureType featureType, StringBuffer sql) {
|
|
|
+ // walk through all geometry attributes and build the query
|
|
|
+ for (AttributeDescriptor attribute : featureType.getAttributeDescriptors()) {
|
|
|
+ if (attribute instanceof GeometryDescriptor) {
|
|
|
+ String geometryColumn = attribute.getLocalName();
|
|
|
+ dialect.encodeGeometryEnvelope(featureType.getTypeName(), geometryColumn, sql);
|
|
|
+ sql.append(",");
|
|
|
+ }
|
|
|
+ }
|
|
|
+ sql.setLength(sql.length() - 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ protected String selectAggregateSQL(
|
|
|
+ String function,
|
|
|
+ Expression att,
|
|
|
+ List<Expression> groupByExpressions,
|
|
|
+ SimpleFeatureType featureType,
|
|
|
+ Query query,
|
|
|
+ LimitingVisitor visitor)
|
|
|
+ throws SQLException, IOException {
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ doSelectAggregateSQL(function, att, groupByExpressions, featureType, query, visitor, sql);
|
|
|
+ return sql.toString();
|
|
|
+ }
|
|
|
+
|
|
|
+ protected PreparedStatement selectAggregateSQLPS(
|
|
|
+ String function,
|
|
|
+ Expression att,
|
|
|
+ List<Expression> groupByExpressions,
|
|
|
+ SimpleFeatureType featureType,
|
|
|
+ Query query,
|
|
|
+ LimitingVisitor visitor,
|
|
|
+ Connection cx)
|
|
|
+ throws SQLException, IOException {
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ List<FilterToSQL> toSQL =
|
|
|
+ doSelectAggregateSQL(
|
|
|
+ function, att, groupByExpressions, featureType, query, visitor, sql);
|
|
|
+
|
|
|
+ LOGGER.fine(sql.toString());
|
|
|
+
|
|
|
+ PreparedStatement ps =
|
|
|
+ cx.prepareStatement(
|
|
|
+ sql.toString(), ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
|
|
|
+ ps.setFetchSize(fetchSize);
|
|
|
+
|
|
|
+ setPreparedFilterValues(ps, toSQL, cx);
|
|
|
+
|
|
|
+ return ps;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Helper method to factor out some commonalities between selectAggregateSQL, and
|
|
|
+ * selectAggregateSQLPS
|
|
|
+ */
|
|
|
+ List<FilterToSQL> doSelectAggregateSQL(
|
|
|
+ String function,
|
|
|
+ Expression expr,
|
|
|
+ List<Expression> groupByExpressions,
|
|
|
+ SimpleFeatureType featureType,
|
|
|
+ Query query,
|
|
|
+ LimitingVisitor visitor,
|
|
|
+ StringBuffer sql)
|
|
|
+ throws SQLException, IOException {
|
|
|
+ JoinInfo join =
|
|
|
+ !query.getJoins().isEmpty() ? JoinInfo.create(query, featureType, this) : null;
|
|
|
+
|
|
|
+ List<FilterToSQL> toSQL = new ArrayList<>();
|
|
|
+ boolean queryLimitOffset = checkLimitOffset(query.getStartIndex(), query.getMaxFeatures());
|
|
|
+ boolean visitorLimitOffset =
|
|
|
+ visitor == null ? false : visitor.hasLimits() && dialect.isLimitOffsetSupported();
|
|
|
+ // grouping over expressions is complex, as we need
|
|
|
+ boolean groupByComplexExpressions = hasComplexExpressions(groupByExpressions);
|
|
|
+ if (queryLimitOffset && !visitorLimitOffset && !groupByComplexExpressions) {
|
|
|
+ if (join != null) {
|
|
|
+ // don't select * to avoid ambigous result set
|
|
|
+ sql.append("SELECT ");
|
|
|
+ dialect.encodeColumnName(null, join.getPrimaryAlias(), sql);
|
|
|
+ sql.append(".* FROM ");
|
|
|
+ } else {
|
|
|
+ sql.append("SELECT * FROM ");
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ sql.append("SELECT ");
|
|
|
+ FilterToSQL filterToSQL = getFilterToSQL(featureType);
|
|
|
+ if (groupByExpressions != null && !groupByExpressions.isEmpty()) {
|
|
|
+ try {
|
|
|
+ // we encode all the group by attributes as columns names
|
|
|
+ int i = 1;
|
|
|
+ for (Expression expression : groupByExpressions) {
|
|
|
+ sql.append(filterToSQL.encodeToString(expression));
|
|
|
+ // if we are using complex group by, we have to given them an alias
|
|
|
+ if (groupByComplexExpressions) {
|
|
|
+ sql.append(" as ").append(getAggregateExpressionAlias(i++));
|
|
|
+ }
|
|
|
+ sql.append(", ");
|
|
|
+ }
|
|
|
+ } catch (FilterToSQLException e) {
|
|
|
+ throw new RuntimeException("Failed to encode group by expressions", e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (groupByComplexExpressions) {
|
|
|
+ // if encoding a sub-query, the source of the aggregation function must
|
|
|
+ // also be given an alias (we could use * too, but there is a risk of conflicts)
|
|
|
+ if (expr != null) {
|
|
|
+ try {
|
|
|
+ sql.append(filterToSQL.encodeToString(expr));
|
|
|
+ sql.append(" as gt_agg_src");
|
|
|
+ } catch (FilterToSQLException e) {
|
|
|
+ throw new RuntimeException("Failed to encode group by expressions", e);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ // remove the last comma and space
|
|
|
+ sql.setLength(sql.length() - 2);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ encodeFunction(function, expr, sql, filterToSQL);
|
|
|
+ }
|
|
|
+ toSQL.add(filterToSQL);
|
|
|
+ sql.append(" FROM ");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (join != null) {
|
|
|
+ encodeTableJoin(featureType, join, query, sql);
|
|
|
+ } else {
|
|
|
+ encodeTableName(
|
|
|
+ featureType.getTypeName(), sql, setKeepWhereClausePlaceHolderHint(query));
|
|
|
+ }
|
|
|
+
|
|
|
+ if (join != null) {
|
|
|
+ toSQL.addAll(encodeWhereJoin(featureType, join, sql));
|
|
|
+ } else {
|
|
|
+ Filter filter = query.getFilter();
|
|
|
+ if (filter != null && !Filter.INCLUDE.equals(filter)) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+ toSQL.add(filter(featureType, filter, sql));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (dialect.isAggregatedSortSupported(function)) {
|
|
|
+ sort(featureType, query.getSortBy(), null, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ // apply limits
|
|
|
+ if (visitorLimitOffset) {
|
|
|
+ applyLimitOffset(sql, visitor.getStartIndex(), visitor.getMaxFeatures());
|
|
|
+ } else if (queryLimitOffset) {
|
|
|
+ applyLimitOffset(sql, query.getStartIndex(), query.getMaxFeatures());
|
|
|
+ }
|
|
|
+ boolean isUniqueCount = visitor instanceof UniqueCountVisitor;
|
|
|
+ // if the limits were in query or there is a group by with complex expressions
|
|
|
+ // or there is a UniqueCountVisitor
|
|
|
+ // we need to roll what was built so far in a sub-query
|
|
|
+ if (queryLimitOffset || groupByComplexExpressions || isUniqueCount) {
|
|
|
+ StringBuffer sql2 = new StringBuffer("SELECT ");
|
|
|
+ try {
|
|
|
+ if (groupByExpressions != null && !groupByExpressions.isEmpty()) {
|
|
|
+ FilterToSQL filterToSQL = getFilterToSQL(featureType);
|
|
|
+ int i = 1;
|
|
|
+ for (Expression expression : groupByExpressions) {
|
|
|
+ if (groupByComplexExpressions) {
|
|
|
+ sql2.append(getAggregateExpressionAlias(i++));
|
|
|
+ } else {
|
|
|
+ sql2.append(filterToSQL.encodeToString(expression));
|
|
|
+ }
|
|
|
+ sql2.append(",");
|
|
|
+ }
|
|
|
+ toSQL.add(filterToSQL);
|
|
|
+ }
|
|
|
+ } catch (FilterToSQLException e) {
|
|
|
+ throw new RuntimeException("Failed to encode group by expressions", e);
|
|
|
+ }
|
|
|
+ FilterToSQL filterToSQL = getFilterToSQL(featureType);
|
|
|
+ boolean countQuery =
|
|
|
+ isUniqueCount || (groupByComplexExpressions && "count".equals(function));
|
|
|
+ if (countQuery) sql2.append("count(*)");
|
|
|
+ else if (groupByComplexExpressions)
|
|
|
+ sql2.append(function).append("(").append("gt_agg_src").append(")");
|
|
|
+ else encodeFunction(function, expr, sql2, filterToSQL);
|
|
|
+ toSQL.add(filterToSQL);
|
|
|
+ sql2.append(" AS gt_result_");
|
|
|
+ sql2.append(" FROM (");
|
|
|
+ sql.insert(0, sql2.toString());
|
|
|
+ sql.append(") gt_limited_");
|
|
|
+ }
|
|
|
+
|
|
|
+ FilterToSQL filterToSQL = getFilterToSQL(featureType);
|
|
|
+ encodeGroupByStatement(groupByExpressions, sql, filterToSQL, groupByComplexExpressions);
|
|
|
+ toSQL.add(filterToSQL);
|
|
|
+
|
|
|
+ // add search hints if the dialect supports them
|
|
|
+ applySearchHints(featureType, query, sql);
|
|
|
+
|
|
|
+ return toSQL;
|
|
|
+ }
|
|
|
+
|
|
|
+ private String getAggregateExpressionAlias(int idx) {
|
|
|
+ return "gt_agg_" + idx;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Returns true if the expressions have anything but property names */
|
|
|
+ private boolean hasComplexExpressions(List<Expression> expressions) {
|
|
|
+ if (expressions == null || expressions.isEmpty()) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ return expressions.stream().anyMatch(x -> !(x instanceof PropertyName));
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Helper method that adds a group by statement to the SQL query. If the list of group by
|
|
|
+ * attributes is empty or NULL no group by statement is add.
|
|
|
+ *
|
|
|
+ * @param groupByExpressions the group by attributes to be encoded
|
|
|
+ * @param sql the sql query buffer
|
|
|
+ */
|
|
|
+ protected void encodeGroupByStatement(
|
|
|
+ List<Expression> groupByExpressions,
|
|
|
+ StringBuffer sql,
|
|
|
+ FilterToSQL filterToSQL,
|
|
|
+ boolean aggregateOnExpression) {
|
|
|
+ if (groupByExpressions == null || groupByExpressions.isEmpty()) {
|
|
|
+ // there is not group by attributes to encode so nothing to do
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ sql.append(" GROUP BY ");
|
|
|
+ int i = 1;
|
|
|
+ for (Expression groupByExpression : groupByExpressions) {
|
|
|
+ if (aggregateOnExpression) {
|
|
|
+ sql.append("gt_agg_" + i++);
|
|
|
+ } else {
|
|
|
+ try {
|
|
|
+ sql.append(filterToSQL.encodeToString(groupByExpression));
|
|
|
+ } catch (FilterToSQLException e) {
|
|
|
+ throw new RuntimeException(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ sql.append(", ");
|
|
|
+ }
|
|
|
+ sql.setLength(sql.length() - 2);
|
|
|
+ }
|
|
|
+
|
|
|
+ protected void encodeFunction(
|
|
|
+ String function, Expression expression, StringBuffer sql, FilterToSQL filterToSQL) {
|
|
|
+ sql.append(function).append("(");
|
|
|
+ if (expression == null) {
|
|
|
+ sql.append("*");
|
|
|
+ } else {
|
|
|
+ try {
|
|
|
+ sql.append(filterToSQL.encodeToString(expression));
|
|
|
+ } catch (FilterToSQLException e) {
|
|
|
+ throw new RuntimeException(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ sql.append(")");
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Generates a 'DELETE FROM' sql statement. */
|
|
|
+ protected String deleteSQL(SimpleFeatureType featureType, Filter filter) throws SQLException {
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+
|
|
|
+ sql.append("DELETE FROM ");
|
|
|
+ encodeTableName(featureType.getTypeName(), sql, null);
|
|
|
+
|
|
|
+ if (filter != null && !Filter.INCLUDE.equals(filter)) {
|
|
|
+ // encode filter
|
|
|
+ try {
|
|
|
+ FilterToSQL toSQL = createFilterToSQL(featureType);
|
|
|
+ sql.append(" ").append(toSQL.encodeToString(filter));
|
|
|
+ } catch (FilterToSQLException e) {
|
|
|
+ throw new RuntimeException(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return sql.toString();
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Generates a 'DELETE FROM' prepared statement. */
|
|
|
+ protected PreparedStatement deleteSQLPS(
|
|
|
+ SimpleFeatureType featureType, Filter filter, Connection cx) throws SQLException {
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+
|
|
|
+ sql.append("DELETE FROM ");
|
|
|
+ encodeTableName(featureType.getTypeName(), sql, null);
|
|
|
+
|
|
|
+ PreparedFilterToSQL toSQL = null;
|
|
|
+ if (filter != null && !Filter.INCLUDE.equals(filter)) {
|
|
|
+ // encode filter
|
|
|
+ try {
|
|
|
+ toSQL = createPreparedFilterToSQL(featureType);
|
|
|
+ sql.append(" ").append(toSQL.encodeToString(filter));
|
|
|
+ } catch (FilterToSQLException e) {
|
|
|
+ throw new RuntimeException(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ LOGGER.fine(sql.toString());
|
|
|
+ PreparedStatement ps = cx.prepareStatement(sql.toString());
|
|
|
+
|
|
|
+ if (toSQL != null) {
|
|
|
+ setPreparedFilterValues(ps, toSQL, 0, cx);
|
|
|
+ }
|
|
|
+
|
|
|
+ return ps;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Generates a 'INSERT INFO' sql statement. */
|
|
|
+ protected String insertSQL(
|
|
|
+ SimpleFeatureType featureType,
|
|
|
+ SimpleFeature feature,
|
|
|
+ KeysFetcher keysFetcher,
|
|
|
+ Connection cx)
|
|
|
+ throws SQLException, IOException {
|
|
|
+ BasicSQLDialect dialect = (BasicSQLDialect) getSQLDialect();
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("INSERT INTO ");
|
|
|
+ encodeTableName(featureType.getTypeName(), sql, null);
|
|
|
+
|
|
|
+ // column names
|
|
|
+ sql.append(" ( ");
|
|
|
+
|
|
|
+ for (int i = 0; i < featureType.getAttributeCount(); i++) {
|
|
|
+ String colName = featureType.getDescriptor(i).getLocalName();
|
|
|
+ // skip the pk columns in case we have exposed them
|
|
|
+ if (keysFetcher.isKey(colName)) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ dialect.encodeColumnName(null, colName, sql);
|
|
|
+ sql.append(",");
|
|
|
+ }
|
|
|
+
|
|
|
+ // primary key values
|
|
|
+ keysFetcher.addKeyColumns(sql);
|
|
|
+ sql.setLength(sql.length() - 1);
|
|
|
+
|
|
|
+ // values
|
|
|
+ sql.append(" ) VALUES ( ");
|
|
|
+
|
|
|
+ for (int i = 0; i < featureType.getAttributeCount(); i++) {
|
|
|
+ AttributeDescriptor att = featureType.getDescriptor(i);
|
|
|
+ String colName = att.getLocalName();
|
|
|
+ // skip the pk columns in case we have exposed them, we grab the
|
|
|
+ // value from the pk itself
|
|
|
+ if (keysFetcher.isKey(colName)) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ Class binding = att.getType().getBinding();
|
|
|
+ EnumMapper mapper = (EnumMapper) att.getUserData().get(JDBCDataStore.JDBC_ENUM_MAP);
|
|
|
+
|
|
|
+ Object value = feature.getAttribute(colName);
|
|
|
+
|
|
|
+ if (value == null) {
|
|
|
+ if (!att.isNillable()) {
|
|
|
+ throw new IOException(
|
|
|
+ "Cannot set a NULL value on the not null column " + colName);
|
|
|
+ }
|
|
|
+
|
|
|
+ sql.append("null");
|
|
|
+ } else {
|
|
|
+ if (Geometry.class.isAssignableFrom(binding)) {
|
|
|
+ try {
|
|
|
+ Geometry g = (Geometry) value;
|
|
|
+ int srid = getGeometrySRID(g, att);
|
|
|
+ int dimension = getGeometryDimension(g, att);
|
|
|
+ dialect.encodeGeometryValue(g, dimension, srid, sql);
|
|
|
+ } catch (IOException e) {
|
|
|
+ throw new RuntimeException(e);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (mapper != null) {
|
|
|
+ value = mapper.fromString((String) value);
|
|
|
+ binding = Integer.class;
|
|
|
+ }
|
|
|
+ dialect.encodeValue(value, binding, sql);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ sql.append(",");
|
|
|
+ }
|
|
|
+ // handle the primary key
|
|
|
+ keysFetcher.setKeyValues(this, cx, featureType, feature, sql);
|
|
|
+ sql.setLength(sql.length() - 1); // remove last comma
|
|
|
+
|
|
|
+ sql.append(")");
|
|
|
+
|
|
|
+ return sql.toString();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the set of the primary key column names. The set is guaranteed to have the same
|
|
|
+ * iteration order as the primary key.
|
|
|
+ */
|
|
|
+ protected static LinkedHashSet<String> getColumnNames(PrimaryKey key) {
|
|
|
+ LinkedHashSet<String> pkColumnNames = new LinkedHashSet<>();
|
|
|
+ for (PrimaryKeyColumn pkcol : key.getColumns()) {
|
|
|
+ pkColumnNames.add(pkcol.getName());
|
|
|
+ }
|
|
|
+ return pkColumnNames;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Looks up the geometry srs by trying a number of heuristics. Returns -1 if all attempts at
|
|
|
+ * guessing the srid failed.
|
|
|
+ */
|
|
|
+ protected int getGeometrySRID(Geometry g, AttributeDescriptor descriptor) throws IOException {
|
|
|
+ int srid = getDescriptorSRID(descriptor);
|
|
|
+
|
|
|
+ if (g == null) {
|
|
|
+ return srid;
|
|
|
+ }
|
|
|
+
|
|
|
+ // check for srid in the jts geometry then
|
|
|
+ if (srid <= 0 && g.getSRID() > 0) {
|
|
|
+ srid = g.getSRID();
|
|
|
+ }
|
|
|
+
|
|
|
+ // check if the geometry has anything
|
|
|
+ if (srid <= 0 && g.getUserData() instanceof CoordinateReferenceSystem) {
|
|
|
+ // check for crs object
|
|
|
+ CoordinateReferenceSystem crs = (CoordinateReferenceSystem) g.getUserData();
|
|
|
+
|
|
|
+ try {
|
|
|
+ Integer candidate = CRS.lookupEpsgCode(crs, false);
|
|
|
+ if (candidate != null) srid = candidate;
|
|
|
+ } catch (Exception e) {
|
|
|
+ // ok, we tried...
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return srid;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Looks up the geometry dimension by trying a number of heuristics. Returns 2 if all attempts
|
|
|
+ * at guessing the dimension failed.
|
|
|
+ */
|
|
|
+ protected int getGeometryDimension(Geometry g, AttributeDescriptor descriptor)
|
|
|
+ throws IOException {
|
|
|
+ int dimension = getDescriptorDimension(descriptor);
|
|
|
+
|
|
|
+ if (g == null || dimension > 0) {
|
|
|
+ return dimension;
|
|
|
+ }
|
|
|
+
|
|
|
+ // check for dimension in the geometry coordinate sequences
|
|
|
+ CoordinateSequenceDimensionExtractor dex = new CoordinateSequenceDimensionExtractor();
|
|
|
+ g.apply(dex);
|
|
|
+ return dex.getDimension();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Extracts the eventual native SRID user property from the descriptor, returns -1 if not found
|
|
|
+ */
|
|
|
+ protected int getDescriptorSRID(AttributeDescriptor descriptor) {
|
|
|
+ int srid = -1;
|
|
|
+
|
|
|
+ // check if we have stored the native srid in the descriptor (we should)
|
|
|
+ if (descriptor.getUserData().get(JDBCDataStore.JDBC_NATIVE_SRID) != null)
|
|
|
+ srid = (Integer) descriptor.getUserData().get(JDBCDataStore.JDBC_NATIVE_SRID);
|
|
|
+
|
|
|
+ return srid;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Extracts the eventual native dimension user property from the descriptor, returns -1 if not
|
|
|
+ * found
|
|
|
+ */
|
|
|
+ protected int getDescriptorDimension(AttributeDescriptor descriptor) {
|
|
|
+ int dimension = -1;
|
|
|
+
|
|
|
+ // check if we have stored the native srid in the descriptor (we should)
|
|
|
+ if (descriptor.getUserData().get(JDBCDataStore.JDBC_NATIVE_SRID) != null) {
|
|
|
+ dimension = (Integer) descriptor.getUserData().get(Hints.COORDINATE_DIMENSION);
|
|
|
+ }
|
|
|
+
|
|
|
+ return dimension;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Generates an 'UPDATE' sql statement. */
|
|
|
+ protected String updateSQL(
|
|
|
+ SimpleFeatureType featureType,
|
|
|
+ AttributeDescriptor[] attributes,
|
|
|
+ Object[] values,
|
|
|
+ Filter filter,
|
|
|
+ Set<String> pkColumnNames)
|
|
|
+ throws IOException, SQLException {
|
|
|
+ BasicSQLDialect dialect = (BasicSQLDialect) getSQLDialect();
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("UPDATE ");
|
|
|
+ encodeTableName(featureType.getTypeName(), sql, null);
|
|
|
+
|
|
|
+ sql.append(" SET ");
|
|
|
+
|
|
|
+ for (int i = 0; i < attributes.length; i++) {
|
|
|
+ // skip exposed pk columns, they are read only
|
|
|
+ AttributeDescriptor att = attributes[i];
|
|
|
+ String attName = att.getLocalName();
|
|
|
+ if (pkColumnNames.contains(attName)) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // build "colName = value"
|
|
|
+ dialect.encodeColumnName(null, attName, sql);
|
|
|
+ sql.append(" = ");
|
|
|
+
|
|
|
+ Class<?> binding = att.getType().getBinding();
|
|
|
+ Object value = values[i];
|
|
|
+ if (Geometry.class.isAssignableFrom(binding)) {
|
|
|
+ try {
|
|
|
+ Geometry g = (Geometry) value;
|
|
|
+ int srid = getGeometrySRID(g, att);
|
|
|
+ int dimension = getGeometryDimension(g, att);
|
|
|
+ dialect.encodeGeometryValue(g, dimension, srid, sql);
|
|
|
+ } catch (IOException e) {
|
|
|
+ throw new RuntimeException(e);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ EnumMapper mapper = (EnumMapper) att.getUserData().get(JDBCDataStore.JDBC_ENUM_MAP);
|
|
|
+ if (mapper != null) {
|
|
|
+ value = mapper.fromString(Converters.convert(value, String.class));
|
|
|
+ binding = Integer.class;
|
|
|
+ }
|
|
|
+ dialect.encodeValue(value, binding, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ sql.append(",");
|
|
|
+ }
|
|
|
+
|
|
|
+ sql.setLength(sql.length() - 1);
|
|
|
+ sql.append(" ");
|
|
|
+
|
|
|
+ if (filter != null && !Filter.INCLUDE.equals(filter)) {
|
|
|
+ // encode filter
|
|
|
+ try {
|
|
|
+ FilterToSQL toSQL = createFilterToSQL(featureType);
|
|
|
+ sql.append(" ").append(toSQL.encodeToString(filter));
|
|
|
+ } catch (FilterToSQLException e) {
|
|
|
+ throw new RuntimeException(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return sql.toString();
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Generates an 'UPDATE' prepared statement. */
|
|
|
+ protected PreparedStatement updateSQLPS(
|
|
|
+ SimpleFeatureType featureType,
|
|
|
+ AttributeDescriptor[] attributes,
|
|
|
+ Object[] values,
|
|
|
+ Filter filter,
|
|
|
+ Set<String> pkColumnNames,
|
|
|
+ Connection cx)
|
|
|
+ throws IOException, SQLException {
|
|
|
+ PreparedStatementSQLDialect dialect = (PreparedStatementSQLDialect) getSQLDialect();
|
|
|
+
|
|
|
+ StringBuffer sql = new StringBuffer();
|
|
|
+ sql.append("UPDATE ");
|
|
|
+ encodeTableName(featureType.getTypeName(), sql, null);
|
|
|
+
|
|
|
+ sql.append(" SET ");
|
|
|
+
|
|
|
+ for (int i = 0; i < attributes.length; i++) {
|
|
|
+ // skip exposed primary key values, they are read only
|
|
|
+ AttributeDescriptor att = attributes[i];
|
|
|
+ String attName = att.getLocalName();
|
|
|
+ if (pkColumnNames.contains(attName)) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ dialect.encodeColumnName(null, attName, sql);
|
|
|
+ sql.append(" = ");
|
|
|
+
|
|
|
+ // geometries might need special treatment, delegate to the dialect
|
|
|
+ if (attributes[i] instanceof GeometryDescriptor) {
|
|
|
+ Geometry geometry = (Geometry) values[i];
|
|
|
+ final Class<?> binding = att.getType().getBinding();
|
|
|
+ dialect.prepareGeometryValue(
|
|
|
+ geometry,
|
|
|
+ getDescriptorDimension(att),
|
|
|
+ getDescriptorSRID(att),
|
|
|
+ binding,
|
|
|
+ sql);
|
|
|
+ } else {
|
|
|
+ sql.append("?");
|
|
|
+ }
|
|
|
+ sql.append(",");
|
|
|
+ }
|
|
|
+ sql.setLength(sql.length() - 1);
|
|
|
+ sql.append(" ");
|
|
|
+
|
|
|
+ PreparedFilterToSQL toSQL = null;
|
|
|
+ if (filter != null && !Filter.INCLUDE.equals(filter)) {
|
|
|
+ // encode filter
|
|
|
+ try {
|
|
|
+ toSQL = createPreparedFilterToSQL(featureType);
|
|
|
+ sql.append(" ").append(toSQL.encodeToString(filter));
|
|
|
+ } catch (FilterToSQLException e) {
|
|
|
+ throw new RuntimeException(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ PreparedStatement ps = cx.prepareStatement(sql.toString());
|
|
|
+ LOGGER.log(Level.FINE, "Updating features with prepared statement: {0}", sql);
|
|
|
+
|
|
|
+ int i = 0;
|
|
|
+ int j = 0;
|
|
|
+ for (; i < attributes.length; i++) {
|
|
|
+ // skip exposed primary key columns
|
|
|
+ AttributeDescriptor att = attributes[i];
|
|
|
+ String attName = att.getLocalName();
|
|
|
+ if (pkColumnNames.contains(attName)) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ Class binding = att.getType().getBinding();
|
|
|
+ Object value = values[i];
|
|
|
+ if (Geometry.class.isAssignableFrom(binding)) {
|
|
|
+ Geometry g = (Geometry) value;
|
|
|
+ dialect.setGeometryValue(
|
|
|
+ g, getDescriptorDimension(att), getDescriptorSRID(att), binding, ps, j + 1);
|
|
|
+ } else {
|
|
|
+ EnumMapper mapper = (EnumMapper) att.getUserData().get(JDBCDataStore.JDBC_ENUM_MAP);
|
|
|
+ if (mapper != null) {
|
|
|
+ value = mapper.fromString(Converters.convert(value, String.class));
|
|
|
+ binding = Integer.class;
|
|
|
+ }
|
|
|
+ dialect.setValue(value, binding, ps, j + 1, cx);
|
|
|
+ }
|
|
|
+ if (LOGGER.isLoggable(Level.FINE)) {
|
|
|
+ LOGGER.fine((j + 1) + " = " + value);
|
|
|
+ }
|
|
|
+ // we do this only if we did not skip the exposed pk
|
|
|
+ j++;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (toSQL != null) {
|
|
|
+ setPreparedFilterValues(ps, toSQL, j, cx);
|
|
|
+ }
|
|
|
+
|
|
|
+ return ps;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates a new instance of a filter to sql encoder.
|
|
|
+ *
|
|
|
+ * <p>The <tt>featureType</tt> may be null but it is not recommended. Such a case where this may
|
|
|
+ * neccessary is when a literal needs to be encoded in isolation.
|
|
|
+ */
|
|
|
+ public FilterToSQL createFilterToSQL(SimpleFeatureType featureType) {
|
|
|
+ return initializeFilterToSQL(((BasicSQLDialect) dialect).createFilterToSQL(), featureType);
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Creates a new instance of a filter to sql encoder to be used in a prepared statement. */
|
|
|
+ public PreparedFilterToSQL createPreparedFilterToSQL(SimpleFeatureType featureType) {
|
|
|
+ return initializeFilterToSQL(
|
|
|
+ ((PreparedStatementSQLDialect) dialect).createPreparedFilterToSQL(), featureType);
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Helper method to initialize a filter encoder instance. */
|
|
|
+ protected <F extends FilterToSQL> F initializeFilterToSQL(
|
|
|
+ F toSQL, final SimpleFeatureType featureType) {
|
|
|
+ toSQL.setSqlNameEscape(dialect.getNameEscape());
|
|
|
+
|
|
|
+ if (featureType != null) {
|
|
|
+ // set up a fid mapper
|
|
|
+ // TODO: remove this
|
|
|
+ final PrimaryKey key;
|
|
|
+
|
|
|
+ try {
|
|
|
+ key = getPrimaryKey(featureType);
|
|
|
+ } catch (IOException e) {
|
|
|
+ throw new RuntimeException(e);
|
|
|
+ }
|
|
|
+
|
|
|
+ toSQL.setFeatureType(featureType);
|
|
|
+ toSQL.setPrimaryKey(key);
|
|
|
+ toSQL.setDatabaseSchema(databaseSchema);
|
|
|
+ }
|
|
|
+
|
|
|
+ return toSQL;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Helper method to encode table name which checks if a schema is set and prefixes the table
|
|
|
+ * name with it.
|
|
|
+ */
|
|
|
+ public void encodeTableName(String tableName, StringBuffer sql, Hints hints)
|
|
|
+ throws SQLException {
|
|
|
+ encodeAliasedTableName(tableName, sql, hints, null);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Helper method to encode table name which checks if a schema is set and prefixes the table
|
|
|
+ * name with it, with the addition of an alias to the name
|
|
|
+ */
|
|
|
+ public void encodeAliasedTableName(
|
|
|
+ String tableName, StringBuffer sql, Hints hints, String alias) throws SQLException {
|
|
|
+ VirtualTable vtDefinition = virtualTables.get(tableName);
|
|
|
+ if (vtDefinition != null) {
|
|
|
+ sql.append("(").append(vtDefinition.expandParameters(hints)).append(")");
|
|
|
+ if (alias == null) {
|
|
|
+ alias = "vtable";
|
|
|
+ }
|
|
|
+ dialect.encodeTableAlias(alias, sql);
|
|
|
+ } else {
|
|
|
+ if (databaseSchema != null) {
|
|
|
+ dialect.encodeSchemaName(databaseSchema, sql);
|
|
|
+ sql.append(".");
|
|
|
+ }
|
|
|
+
|
|
|
+ dialect.encodeTableName(tableName, sql);
|
|
|
+ if (alias != null) {
|
|
|
+ dialect.encodeTableAlias(alias, sql);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Helper method to encode the join clause(s) of a query. */
|
|
|
+ protected void encodeTableJoin(
|
|
|
+ SimpleFeatureType featureType, JoinInfo join, Query query, StringBuffer sql)
|
|
|
+ throws SQLException {
|
|
|
+ encodeAliasedTableName(
|
|
|
+ featureType.getTypeName(), sql, query.getHints(), join.getPrimaryAlias());
|
|
|
+
|
|
|
+ for (JoinPart part : join.getParts()) {
|
|
|
+ sql.append(" ");
|
|
|
+ dialect.encodeJoin(part.getJoin().getType(), sql);
|
|
|
+ sql.append(" ");
|
|
|
+ encodeAliasedTableName(
|
|
|
+ part.getQueryFeatureType().getTypeName(),
|
|
|
+ sql,
|
|
|
+ setKeepWhereClausePlaceHolderHint(null, true),
|
|
|
+ part.getAlias());
|
|
|
+ sql.append(" ON ");
|
|
|
+
|
|
|
+ Filter j = part.getJoinFilter();
|
|
|
+
|
|
|
+ FilterToSQL toSQL = getFilterToSQL(null);
|
|
|
+ toSQL.setInline(true);
|
|
|
+ try {
|
|
|
+ sql.append(" ").append(toSQL.encodeToString(j));
|
|
|
+ } catch (FilterToSQLException e) {
|
|
|
+ throw new RuntimeException(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (sql.indexOf(WHERE_CLAUSE_PLACE_HOLDER) >= 0) {
|
|
|
+ // this means that one of the joined table provided a placeholder
|
|
|
+ throw new RuntimeException(
|
|
|
+ "Joins between virtual tables that provide a :where_placeholder: are not supported: "
|
|
|
+ + sql);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ protected List<FilterToSQL> encodeWhereJoin(
|
|
|
+ SimpleFeatureType featureType, JoinInfo join, StringBuffer sql) throws IOException {
|
|
|
+
|
|
|
+ List<FilterToSQL> toSQL = new ArrayList<>();
|
|
|
+
|
|
|
+ boolean whereEncoded = false;
|
|
|
+ Filter filter = join.getFilter();
|
|
|
+ if (filter != null && !Filter.INCLUDE.equals(filter)) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+ whereEncoded = true;
|
|
|
+
|
|
|
+ // encode filter
|
|
|
+ toSQL.add(filter(featureType, filter, sql));
|
|
|
+ }
|
|
|
+
|
|
|
+ // filters for joined feature types
|
|
|
+ for (JoinPart part : join.getParts()) {
|
|
|
+ filter = part.getPreFilter();
|
|
|
+ if (filter == null || Filter.INCLUDE.equals(filter)) continue;
|
|
|
+
|
|
|
+ if (!whereEncoded) {
|
|
|
+ sql.append(" WHERE ");
|
|
|
+ whereEncoded = true;
|
|
|
+ } else {
|
|
|
+ sql.append(" AND ");
|
|
|
+ }
|
|
|
+
|
|
|
+ toSQL.add(filter(part.getQueryFeatureType(), filter, sql));
|
|
|
+ }
|
|
|
+
|
|
|
+ return toSQL;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Helper method for setting the gml:id of a geometry as user data. */
|
|
|
+ protected void setGmlProperties(Geometry g, String gid, String name, String description) {
|
|
|
+ // set up the user data
|
|
|
+ Map<Object, Object> userData = null;
|
|
|
+
|
|
|
+ if (g.getUserData() != null) {
|
|
|
+ if (g.getUserData() instanceof Map) {
|
|
|
+ @SuppressWarnings("unchecked")
|
|
|
+ Map<Object, Object> cast = (Map) g.getUserData();
|
|
|
+ userData = cast;
|
|
|
+ } else {
|
|
|
+ userData = new HashMap<>();
|
|
|
+ userData.put(g.getUserData().getClass(), g.getUserData());
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ userData = new HashMap<>();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (gid != null) {
|
|
|
+ userData.put("gml:id", gid);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (name != null) {
|
|
|
+ userData.put("gml:name", name);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (description != null) {
|
|
|
+ userData.put("gml:description", description);
|
|
|
+ }
|
|
|
+
|
|
|
+ g.setUserData(userData);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Applies the givenb limit/offset elements if the dialect supports them
|
|
|
+ *
|
|
|
+ * @param sql The sql to be modified
|
|
|
+ * @param offset starting index
|
|
|
+ * @param limit max number of features
|
|
|
+ */
|
|
|
+ void applyLimitOffset(StringBuffer sql, final Integer offset, final int limit) {
|
|
|
+ if (checkLimitOffset(offset, limit)) {
|
|
|
+ dialect.applyLimitOffset(sql, limit, offset != null ? offset : 0);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Applies the limit/offset elements to the query if they are specified and if the dialect
|
|
|
+ * supports them
|
|
|
+ *
|
|
|
+ * @param sql The sql to be modified
|
|
|
+ * @param query the query that holds the limit and offset parameters
|
|
|
+ */
|
|
|
+ public void applyLimitOffset(StringBuffer sql, Query query) {
|
|
|
+ applyLimitOffset(sql, query.getStartIndex(), query.getMaxFeatures());
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Checks if the query needs limit/offset treatment
|
|
|
+ *
|
|
|
+ * @return true if the query needs limit/offset treatment and if the sql dialect can do that
|
|
|
+ * natively
|
|
|
+ */
|
|
|
+ boolean checkLimitOffset(final Integer offset, final int limit) {
|
|
|
+ // if we cannot, don't bother checking the query
|
|
|
+ if (!dialect.isLimitOffsetSupported()) return false;
|
|
|
+
|
|
|
+ return limit != Integer.MAX_VALUE || (offset != null && offset > 0);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Utility method for closing a result set.
|
|
|
+ *
|
|
|
+ * <p>This method closed the result set "safely" in that it never throws an exception. Any
|
|
|
+ * exceptions that do occur are logged at {@link Level#FINER}.
|
|
|
+ *
|
|
|
+ * @param rs The result set to close.
|
|
|
+ */
|
|
|
+ public void closeSafe(ResultSet rs) {
|
|
|
+ if (rs == null) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ try {
|
|
|
+ rs.close();
|
|
|
+ } catch (SQLException e) {
|
|
|
+ String msg = "Error occurred closing result set";
|
|
|
+ LOGGER.warning(msg);
|
|
|
+
|
|
|
+ if (LOGGER.isLoggable(Level.FINER)) {
|
|
|
+ LOGGER.log(Level.FINER, msg, e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Utility method for closing a statement.
|
|
|
+ *
|
|
|
+ * <p>This method closed the statement"safely" in that it never throws an exception. Any
|
|
|
+ * exceptions that do occur are logged at {@link Level#FINER}.
|
|
|
+ *
|
|
|
+ * @param st The statement to close.
|
|
|
+ */
|
|
|
+ public void closeSafe(Statement st) {
|
|
|
+ if (st == null) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ try {
|
|
|
+ st.close();
|
|
|
+ } catch (SQLException e) {
|
|
|
+ String msg = "Error occurred closing statement";
|
|
|
+ LOGGER.warning(msg);
|
|
|
+
|
|
|
+ if (LOGGER.isLoggable(Level.FINER)) {
|
|
|
+ LOGGER.log(Level.FINER, msg, e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Utility method for closing a connection.
|
|
|
+ *
|
|
|
+ * <p>This method closed the connection "safely" in that it never throws an exception. Any
|
|
|
+ * exceptions that do occur are logged at {@link Level#FINER}.
|
|
|
+ *
|
|
|
+ * @param cx The connection to close.
|
|
|
+ */
|
|
|
+ public void closeSafe(Connection cx) {
|
|
|
+ if (cx == null) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ try {
|
|
|
+ // System.out.println("Closing connection " + System.identityHashCode(cx));
|
|
|
+ cx.close();
|
|
|
+ LOGGER.fine("CLOSE CONNECTION");
|
|
|
+ } catch (SQLException e) {
|
|
|
+ String msg = "Error occurred closing connection";
|
|
|
+ LOGGER.warning(msg);
|
|
|
+
|
|
|
+ if (LOGGER.isLoggable(Level.FINER)) {
|
|
|
+ LOGGER.log(Level.FINER, msg, e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ @Override
|
|
|
+ @SuppressWarnings("deprecation") // finalize is deprecated in Java 9
|
|
|
+ protected void finalize() throws Throwable {
|
|
|
+ if (dataSource != null) {
|
|
|
+ LOGGER.severe(
|
|
|
+ "There's code using JDBC based datastore and "
|
|
|
+ + "not disposing them. This may lead to temporary loss of database connections. "
|
|
|
+ + "Please make sure all data access code calls DataStore.dispose() "
|
|
|
+ + "before freeing all references to it");
|
|
|
+ dispose();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ @Override
|
|
|
+ public void dispose() {
|
|
|
+ super.dispose();
|
|
|
+ if (dataSource != null && dataSource instanceof ManageableDataSource) {
|
|
|
+ try {
|
|
|
+ @SuppressWarnings("PMD.CloseResource") // actually closing it here
|
|
|
+ ManageableDataSource mds = (ManageableDataSource) dataSource;
|
|
|
+ mds.close();
|
|
|
+ } catch (SQLException e) {
|
|
|
+ // it's ok, we did our best..
|
|
|
+ LOGGER.log(Level.FINE, "Could not close dataSource", e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // Store the exception for logging later if the object is used after disposal
|
|
|
+ if (TRACE_ENABLED) {
|
|
|
+ disposedBy =
|
|
|
+ new RuntimeException(
|
|
|
+ "DataSource disposed by thread " + Thread.currentThread().getName());
|
|
|
+ }
|
|
|
+ dataSource = null;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Checks if geometry generalization required and makes sense
|
|
|
+ *
|
|
|
+ * @param hints hints hints passed in
|
|
|
+ * @param gatt Geometry attribute descriptor
|
|
|
+ * @return true to indicate generalization
|
|
|
+ */
|
|
|
+ protected boolean isGeneralizationRequired(Hints hints, GeometryDescriptor gatt) {
|
|
|
+ return isGeometryReduceRequired(hints, gatt, Hints.GEOMETRY_GENERALIZATION);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Checks if geometry simplification required and makes sense
|
|
|
+ *
|
|
|
+ * @param hints hints hints passed in
|
|
|
+ * @param gatt Geometry attribute descriptor
|
|
|
+ * @return true to indicate simplification
|
|
|
+ */
|
|
|
+ protected boolean isSimplificationRequired(Hints hints, GeometryDescriptor gatt) {
|
|
|
+ return isGeometryReduceRequired(hints, gatt, Hints.GEOMETRY_SIMPLIFICATION);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Checks if reduction required and makes sense
|
|
|
+ *
|
|
|
+ * @param hints hints passed in
|
|
|
+ * @param gatt Geometry attribute descriptor
|
|
|
+ * @param param {@link Hints#GEOMETRY_GENERALIZATION} or {@link Hints#GEOMETRY_SIMPLIFICATION}
|
|
|
+ * @return true to indicate reducing the geometry, false otherwise
|
|
|
+ */
|
|
|
+ protected boolean isGeometryReduceRequired(
|
|
|
+ Hints hints, GeometryDescriptor gatt, Hints.Key param) {
|
|
|
+ if (hints == null) return false;
|
|
|
+ if (hints.containsKey(param) == false) return false;
|
|
|
+ if (gatt.getType().getBinding() == Point.class && !dialect.canSimplifyPoints())
|
|
|
+ return false;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Encoding a geometry column with respect to hints Supported Hints are provided by {@link
|
|
|
+ * SQLDialect#addSupportedHints(Set)}
|
|
|
+ *
|
|
|
+ * @param hints , may be null
|
|
|
+ */
|
|
|
+ public void encodeGeometryColumn(GeometryDescriptor gatt, StringBuffer sql, Hints hints) {
|
|
|
+ encodeGeometryColumn(gatt, null, sql, hints);
|
|
|
+ }
|
|
|
+
|
|
|
+ protected void encodeGeometryColumn(
|
|
|
+ GeometryDescriptor gatt, String prefix, StringBuffer sql, Hints hints) {
|
|
|
+
|
|
|
+ int srid = getDescriptorSRID(gatt);
|
|
|
+ if (isGeneralizationRequired(hints, gatt) == true) {
|
|
|
+ Double distance = (Double) hints.get(Hints.GEOMETRY_GENERALIZATION);
|
|
|
+ dialect.encodeGeometryColumnGeneralized(gatt, prefix, srid, sql, distance);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (isSimplificationRequired(hints, gatt) == true) {
|
|
|
+ Double distance = (Double) hints.get(Hints.GEOMETRY_SIMPLIFICATION);
|
|
|
+ dialect.encodeGeometryColumnSimplified(gatt, prefix, srid, sql, distance);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ dialect.encodeGeometryColumn(gatt, prefix, srid, hints, sql);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Builds a transaction object around a user provided connection. The returned transaction
|
|
|
+ * allows the store to work against an externally managed transaction, such as in J2EE
|
|
|
+ * enviroments. It is the duty of the caller to ensure the connection is to the same database
|
|
|
+ * managed by this {@link JDBCDataStore}.
|
|
|
+ *
|
|
|
+ * <p>Calls to {@link Transaction#commit()}, {@link Transaction#rollback()} and {@link
|
|
|
+ * Transaction#close()} will not result in corresponding calls to the provided {@link
|
|
|
+ * Connection} object.
|
|
|
+ *
|
|
|
+ * @param cx The externally managed connection
|
|
|
+ */
|
|
|
+ public Transaction buildTransaction(Connection cx) {
|
|
|
+ DefaultTransaction tx = new DefaultTransaction();
|
|
|
+
|
|
|
+ State state = new JDBCTransactionState(cx, this, true);
|
|
|
+ tx.putState(this, state);
|
|
|
+
|
|
|
+ return tx;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Creates a new database index */
|
|
|
+ public void createIndex(Index index) throws IOException {
|
|
|
+ SimpleFeatureType schema = getSchema(index.typeName);
|
|
|
+ Connection cx = null;
|
|
|
+ try {
|
|
|
+ cx = getConnection(Transaction.AUTO_COMMIT);
|
|
|
+ dialect.createIndex(cx, schema, databaseSchema, index);
|
|
|
+ } catch (SQLException e) {
|
|
|
+ throw new IOException("Failed to create index", e);
|
|
|
+ } finally {
|
|
|
+ closeSafe(cx);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /** Creates a new database index */
|
|
|
+ public void dropIndex(String typeName, String indexName) throws IOException {
|
|
|
+ SimpleFeatureType schema = getSchema(typeName);
|
|
|
+
|
|
|
+ Connection cx = null;
|
|
|
+ try {
|
|
|
+ cx = getConnection(Transaction.AUTO_COMMIT);
|
|
|
+ dialect.dropIndex(cx, schema, databaseSchema, indexName);
|
|
|
+ } catch (SQLException e) {
|
|
|
+ throw new IOException("Failed to create index", e);
|
|
|
+ } finally {
|
|
|
+ closeSafe(cx);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Lists all indexes associated to the given feature type
|
|
|
+ *
|
|
|
+ * @param typeName Name of the type for which indexes are searched. It's mandatory
|
|
|
+ */
|
|
|
+ public List<Index> getIndexes(String typeName) throws IOException {
|
|
|
+ // just to ensure we have the type name specified
|
|
|
+ getSchema(typeName);
|
|
|
+
|
|
|
+ Connection cx = null;
|
|
|
+ try {
|
|
|
+ cx = getConnection(Transaction.AUTO_COMMIT);
|
|
|
+ return dialect.getIndexes(cx, databaseSchema, typeName);
|
|
|
+ } catch (SQLException e) {
|
|
|
+ throw new IOException("Failed to create index", e);
|
|
|
+ } finally {
|
|
|
+ closeSafe(cx);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Escapes a name pattern used in e.g. {@link DatabaseMetaData#getColumns(String,
|
|
|
+ * String, String, String)} when passed in argument is an exact name and not a pattern.
|
|
|
+ *
|
|
|
+ * <p>When a table name or column name contains underscore (or percen, but this is rare) the
|
|
|
+ * underscore is treated as a placeholder and not an actual character. So if our intention is to
|
|
|
+ * match an exact name, we must escape such characters.
|
|
|
+ */
|
|
|
+ public String escapeNamePattern(DatabaseMetaData metaData, String name) throws SQLException {
|
|
|
+ if (namePatternEscaping == null) {
|
|
|
+ namePatternEscaping = new NamePatternEscaping(metaData.getSearchStringEscape());
|
|
|
+ }
|
|
|
+ return namePatternEscaping.escape(name);
|
|
|
+ }
|
|
|
+
|
|
|
+ public boolean hasSchema(String typeName) throws IOException {
|
|
|
+ Statement statement = null;
|
|
|
+ try {
|
|
|
+ statement = getConnection(Transaction.AUTO_COMMIT).createStatement();
|
|
|
+ ResultSet resultSet = statement.executeQuery("select count(1) as cot from pg_stat_user_tables where schemaname = 'public' and relname = '"+typeName+"'");
|
|
|
+ resultSet.next();
|
|
|
+ return resultSet.getInt("cot") > 0;
|
|
|
+ } catch (SQLException throwables) {
|
|
|
+ throwables.printStackTrace();
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+}
|
