Class JDBCDataStore

  • All Implemented Interfaces:
    DataAccess<SimpleFeatureType,​SimpleFeature>, DataStore, GmlObjectStore

    public final class JDBCDataStore
    extends ContentDataStore
    implements GmlObjectStore
    Datastore implementation for jdbc based relational databases.

    This class is not intended to be subclassed on a per database basis. Instead the notion of a "dialect" is used.

    Dialects

    A dialect (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 setSQLDialect(SQLDialect).

    Database Connections

    Connections to the underlying database are obtained through a DataSource. A datastore must be specified using setDataSource(DataSource).

    Schemas

    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 setDatabaseSchema(String).

    Spatial Functions

    The set of spatial operations or functions that are supported by the specific database are reported with a FilterCapabilities instance. This is specified using #setFilterCapabilities(FilterCapabilities).
    Author:
    Justin Deoliveira, The Open Planning Project
    • Field Detail

      • TRACE_ENABLED

        protected static final Boolean TRACE_ENABLED
        When true, record a stack trace documenting who disposed the JDBCDataStore. If dispose() is called a second time we can identify the offending parties.
      • JDBC_NATIVE_SRID

        public static final String JDBC_NATIVE_SRID
        The native SRID associated to a certain descriptor TODO: qualify this key with 'org.geotools.jdbc'
        See Also:
        Constant Field Values
      • JDBC_READ_ONLY

        public static final String JDBC_READ_ONLY
        Boolean marker stating whether the feature type is to be considered read only
        See Also:
        Constant Field Values
      • JDBC_PRIMARY_KEY_COLUMN

        public static final String JDBC_PRIMARY_KEY_COLUMN
        Boolean marker stating whether an attribute is part of the primary key
        See Also:
        Constant Field Values
      • JDBC_NATIVE_TYPENAME

        public static final String JDBC_NATIVE_TYPENAME
        The key for attribute descriptor user data which specifies the original database column data type.
        See Also:
        Constant Field Values
      • JDBC_NATIVE_TYPE

        public static final String JDBC_NATIVE_TYPE
        The key for attribute descriptor user data which specifies the original database column data type, as a Types value.
        See Also:
        Constant Field Values
      • JDBC_COLUMN_ALIAS

        public static final String JDBC_COLUMN_ALIAS
        Used to specify the column alias to use when encoding a column in a select
        See Also:
        Constant Field Values
      • JDBC_ENUM_MAP

        public static final String JDBC_ENUM_MAP
        Contains a EnumMapper to support enums mapped from integer values
        See Also:
        Constant Field Values
      • MULTI_GEOMETRY_TABLE

        protected static final String MULTI_GEOMETRY_TABLE
        name of table to use to store multi geometries made up of non-multi geometries when associations is set.
        See Also:
        Constant Field Values
      • GEOMETRY_ASSOCIATION_TABLE

        protected static final String GEOMETRY_ASSOCIATION_TABLE
        name of table to use to store geometry associations when associations is set.
        See Also:
        Constant Field Values
      • FEATURE_RELATIONSHIP_TABLE

        protected static final String FEATURE_RELATIONSHIP_TABLE
        name of table to use to store feature relationships (information about associations) when associations is set.
        See Also:
        Constant Field Values
      • FEATURE_ASSOCIATION_TABLE

        protected static final String FEATURE_ASSOCIATION_TABLE
        name of table to use to store feature associations when associations is set.
        See Also:
        Constant Field Values
      • EMPTY_ENVELOPE

        protected static final ReferencedEnvelope EMPTY_ENVELOPE
        The envelope returned when bounds is called against a geometryless feature type
      • MAX_IDS_IN_FILTER

        public static final int MAX_IDS_IN_FILTER
        Max number of ids to use for the optimized locks checking filter.
        See Also:
        Constant Field Values
      • dataSource

        protected DataSource dataSource
        data source
      • dialect

        public SQLDialect dialect
        the dialect of sql
      • databaseSchema

        protected String databaseSchema
        The database schema.
      • sqlTypeToClassMappings

        protected HashMap<Integer,​Class<?>> sqlTypeToClassMappings
        sql type to java class mappings
      • sqlTypeNameToClassMappings

        protected HashMap<String,​Class<?>> sqlTypeNameToClassMappings
        sql type name to java class mappings
      • classToSqlTypeMappings

        protected HashMap<Class<?>,​Integer> classToSqlTypeMappings
        java class to sql type mappings;
      • sqlTypeToSqlTypeNameOverrides

        protected HashMap<Integer,​String> sqlTypeToSqlTypeNameOverrides
        sql type to sql type name overrides
      • dBsqlTypesCache

        protected ConcurrentHashMap<Integer,​String> dBsqlTypesCache
        cache of sqltypes found in database
      • aggregateFunctions

        protected HashMap<Class<? extends FeatureVisitor>,​String> aggregateFunctions
        Feature visitor to aggregate function name
      • supportedFunctions

        protected HashMap<String,​String> supportedFunctions
        java supported filter function mappings to dialect name;
      • associations

        protected boolean associations
        flag controlling if the datastore is supporting feature and geometry relationships with associations
      • fetchSize

        public int fetchSize
        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.
      • batchInsertSize

        protected int batchInsertSize
        The number of features to bufferize while inserting in order to do batch inserts.

        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.

      • exposePrimaryKeyColumns

        protected boolean exposePrimaryKeyColumns
        flag controlling whether primary key columns of a table are exposed via the feature type.
      • primaryKeyFinder

        protected PrimaryKeyFinder primaryKeyFinder
        Finds the primary key definitions (instantiated here because the finders might keep state)
      • virtualTables

        protected Map<String,​VirtualTable> virtualTables
        Contains the SQL definition of the various virtual tables
      • connectionLifecycleListeners

        protected List<ConnectionLifecycleListener> connectionLifecycleListeners
        The listeners that are allowed to handle the connection lifecycle
    • Constructor Detail

      • JDBCDataStore

        public JDBCDataStore()
    • Method Detail

      • getAbsoluteFeatureSource

        public JDBCFeatureSource getAbsoluteFeatureSource​(String typeName)
                                                   throws IOException
        Throws:
        IOException
      • createVirtualTable

        public void createVirtualTable​(VirtualTable vtable)
                                throws IOException
        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
      • getConnectionLifecycleListeners

        public List<ConnectionLifecycleListener> getConnectionLifecycleListeners()
        Returns a modifiable list of connection lifecycle listeners
      • dropVirtualTable

        public VirtualTable dropVirtualTable​(String name)
        Removes and returns the specified virtual table
      • getVirtualTables

        public Map<String,​VirtualTable> getVirtualTables()
        Returns a live, immutable view of the virtual tables map (from name to definition)
      • setPrimaryKeyFinder

        public void setPrimaryKeyFinder​(PrimaryKeyFinder primaryKeyFinder)
        Sets the finder used to build PrimaryKey representations
      • getFetchSize

        public int getFetchSize()
        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.
      • setFetchSize

        public void setFetchSize​(int fetchSize)
        Changes the fetch size.
      • getBatchInsertSize

        public int getBatchInsertSize()
        Returns:
        the number of features to bufferize while inserting in order to do batch inserts.
      • setBatchInsertSize

        public void setBatchInsertSize​(int batchInsertSize)
        Set the number of features to bufferize while inserting in order to do batch inserts.

        Warning: when changing this value from its default of 1, the behavior of the 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.

      • isExposePrimaryKeyColumns

        public boolean isExposePrimaryKeyColumns()
        Determines if the datastore creates feature types which include those columns / attributes which compose the primary key.
      • setExposePrimaryKeyColumns

        public void setExposePrimaryKeyColumns​(boolean exposePrimaryKeyColumns)
        Sets the flag controlling if the datastore creates feature types which include those columns / attributes which compose the primary key.
      • getSQLDialect

        public SQLDialect getSQLDialect()
        The dialect the datastore uses to generate sql statements in order to communicate with the underlying database.
        Returns:
        The dialect, never null.
      • setSQLDialect

        public void setSQLDialect​(SQLDialect dialect)
        Sets the dialect the datastore uses to generate sql statements in order to communicate with the underlying database.
        Parameters:
        dialect - The dialect, never null.
      • getDataSource

        public DataSource getDataSource()
        The data source the datastore uses to obtain connections to the underlying database.
        Returns:
        The data source, never null.
      • setDataSource

        public void setDataSource​(DataSource dataSource)
        Sets the data source the datastore uses to obtain connections to the underlying database.
        Parameters:
        dataSource - The data source, never null.
      • getDatabaseSchema

        public String getDatabaseSchema()
        The schema from which this datastore is serving tables from.
        Returns:
        the schema, or null if non specified.
      • setDatabaseSchema

        public void setDatabaseSchema​(String databaseSchema)
        Set the database schema for the datastore.

        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 null to specify no particular schema.

        Parameters:
        databaseSchema - The schema, may be null.
      • getFilterCapabilities

        public FilterCapabilities getFilterCapabilities()
        The filter capabilities which reports which spatial operations the underlying database can handle natively.
        Returns:
        The filter capabilities, never null.
      • isAssociations

        public boolean isAssociations()
        Flag controlling if the datastore is supporting feature and geometry relationships with associations
      • setAssociations

        public void setAssociations​(boolean foreignKeyGeometries)
        Sets the flag controlling if the datastore is supporting feature and geometry relationships with associations
      • getSqlTypeToClassMappings

        public Map<Integer,​Class<?>> getSqlTypeToClassMappings()
        The sql type to java type mappings that the datastore uses when reading and writing objects to and from the database.

        These mappings are derived from SQLDialect.registerSqlTypeToClassMappings(java.util.Map)

        Returns:
        The mappings, never null.
      • getSqlTypeNameToClassMappings

        public Map<String,​Class<?>> getSqlTypeNameToClassMappings()
        The sql type name to java type mappings that the dialect uses when reading and writing objects to and from the database.

        These mappings are derived from SQLDialect.registerSqlTypeNameToClassMappings(Map)

        Returns:
        The mappings, never null.
      • getClassToSqlTypeMappings

        public Map<Class<?>,​Integer> getClassToSqlTypeMappings()
        The java type to sql type mappings that the datastore uses when reading and writing objects to and from the database.

        These mappings are derived from SQLDialect.registerClassToSqlMappings(Map)

        Returns:
        The mappings, never null.
      • getSqlTypeToSqlTypeNameOverrides

        public Map<Integer,​String> getSqlTypeToSqlTypeNameOverrides()
        Returns any ovverides which map integer constants for database types (from Types) to database type names.

        This method will return an empty map when there are no overrides.

      • getDBsqlTypesCache

        public ConcurrentHashMap<Integer,​String> getDBsqlTypesCache()
        Returns a map integer constants for database types (from Types) to database type names.

        This method will return an empty map when there are no overrides.

      • getAggregateFunctions

        public Map<Class<? extends FeatureVisitor>,​String> getAggregateFunctions()
        Returns the supported aggregate functions and the visitors they map to.
      • getMapping

        public Class<?> getMapping​(int sqlType)
        Returns the java type mapped to the specified sql type.

        If there is no such type mapped to sqlType, null is returned.

        Parameters:
        sqlType - The integer constant for the sql type from Types.
        Returns:
        The mapped java class, or null. if no such mapping exists.
      • getMapping

        public Class<?> getMapping​(String sqlTypeName)
        Returns the java type mapped to the specified sql type name.

        If there is no such type mapped to sqlTypeName, null is returned.

        Parameters:
        sqlTypeName - The name of the sql type.
        Returns:
        The mapped java class, or null. if no such mapping exists.
      • getMapping

        public Integer getMapping​(Class<?> clazz)
        Returns the sql type mapped to the specified java type.

        If there is no such type mapped to clazz, Types.OTHER is returned.

        Parameters:
        clazz - The java class.
        Returns:
        The mapped sql type from Types, Types.OTHER if no such mapping exists.
      • createSchema

        public void createSchema​(SimpleFeatureType featureType)
                          throws IOException
        Creates a table in the underlying database from the specified table.

        This method will map the classes of the attributes of featureType to sql types and generate a 'CREATE TABLE' statement against the underlying database.

        Specified by:
        createSchema in interface DataAccess<SimpleFeatureType,​SimpleFeature>
        Overrides:
        createSchema in class ContentDataStore
        Parameters:
        featureType - FetureType to add to DataStore
        Throws:
        IllegalArgumentException - If the table already exists.
        IOException - If the table cannot be created due to an error.
        See Also:
        DataStore#createSchema(SimpleFeatureType)
      • removeSchema

        public void removeSchema​(String typeName)
                          throws IOException
        Description copied from interface: DataStore
        Used to permanently remove a schema from the underlying storage

        This functionality is similar to an "drop table" statement in SQL. Implementation is optional; it may not be supported by all servers or files.

        Specified by:
        removeSchema in interface DataStore
        Overrides:
        removeSchema in class ContentDataStore
        Throws:
        IOException - if the operation failed
        See Also:
        DataStore.removeSchema(String)
      • getGmlObject

        public Object getGmlObject​(GmlObjectId id,
                                   Hints hints)
                            throws IOException
        Description copied from interface: GmlObjectStore
        Looks up an object by its gml id.

        This method returns null if no such object exists.

        Specified by:
        getGmlObject in interface GmlObjectStore
        Parameters:
        id - The id of the object, must not be null.
        hints - Any hints to use when looking up the gml object, this value may be null .
        Returns:
        The gml object, or null if one could not be found matching the specified id.
        Throws:
        IOException - Any I/O errors that occur.
      • createTypeNames

        protected List<Name> createTypeNames()
                                      throws IOException
        Generates the list of type names provided by the database.

        The list is generated from the underlying database metadata.

        Specified by:
        createTypeNames in class ContentDataStore
        Returns:
        A list of Name.
        Throws:
        IOException - Any errors occuring connecting to data.
      • getPrimaryKey

        protected PrimaryKey getPrimaryKey​(ContentEntry entry)
                                    throws IOException
        Returns the primary key object for a particular entry, deriving it from the underlying database metadata.
        Throws:
        IOException
      • getColumnType

        protected Class getColumnType​(DatabaseMetaData metaData,
                                      String databaseSchema2,
                                      String tableName,
                                      String columnName)
                               throws SQLException
        Returns the type of the column by inspecting the metadata, with the collaboration of the dialect
        Throws:
        SQLException
      • getPrimaryKey

        public PrimaryKey getPrimaryKey​(SimpleFeatureType featureType)
                                 throws IOException
        Returns the primary key object for a particular feature type / table, deriving it from the underlying database metadata.
        Throws:
        IOException
      • isExposePrimaryKeyColumns

        protected boolean isExposePrimaryKeyColumns​(SimpleFeatureType featureType)
                                             throws IOException
        Returns the expose primary key columns flag for the specified feature type
        Throws:
        IOException
      • getBounds

        protected ReferencedEnvelope getBounds​(SimpleFeatureType featureType,
                                               Query query,
                                               Connection cx)
                                        throws IOException
        Returns the bounds of the features for a particular feature type / table.
        Parameters:
        featureType - The feature type / table.
        query - Specifies rows to include in bounds calculation, as well as how many features and the offset if needed
        Throws:
        IOException
      • getCount

        protected int getCount​(SimpleFeatureType featureType,
                               Query query,
                               Connection cx)
                        throws IOException
        Returns the count of the features for a particular feature type / table.
        Throws:
        IOException
      • getAggregateValue

        protected Object getAggregateValue​(FeatureVisitor visitor,
                                           SimpleFeatureType featureType,
                                           Query query,
                                           Connection cx)
                                    throws IOException
        Results the value of an aggregate function over a query.
        Returns:
        generated result, or null if unsupported
        Throws:
        IOException
      • isCountVisitor

        protected boolean isCountVisitor​(FeatureVisitor visitor)
      • isGroupByVisitor

        protected boolean isGroupByVisitor​(FeatureVisitor visitor)
        Helper method the checks if a feature visitor is a group by visitor,
        Parameters:
        visitor - the feature visitor
        Returns:
        TRUE if the visitor is a group by visitor otherwise FALSE
      • matchAggregateFunction

        protected String matchAggregateFunction​(FeatureVisitor visitor)
        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.
        Parameters:
        visitor - the feature visitor
        Returns:
        the match aggregate function name, or NULL if no match
      • extractGroupByExpressions

        protected List<Expression> extractGroupByExpressions​(FeatureVisitor visitor)
        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.
        Parameters:
        visitor - the feature visitor
        Returns:
        the list of the group by attributes or an empty list
      • extractValuesFromResultSet

        protected GroupByVisitor.GroupByRawResult extractValuesFromResultSet​(Connection cx,
                                                                             SimpleFeatureType featureType,
                                                                             ResultSet resultSet,
                                                                             List<Expression> groupBy,
                                                                             Function<Object,​Object> converter,
                                                                             Hints hints)
                                                                      throws SQLException,
                                                                             IOException
        Helper method that translate the result set to the appropriate group by visitor result format
        Throws:
        SQLException
        IOException
      • insert

        protected void insert​(SimpleFeature feature,
                              SimpleFeatureType featureType,
                              Connection cx)
                       throws IOException
        Inserts a new feature into the database for a particular feature type / table.
        Throws:
        IOException
      • insert

        protected void insert​(Collection<? extends SimpleFeature> features,
                              SimpleFeatureType featureType,
                              Connection cx)
                       throws IOException
        Inserts a collection of new features into the database for a particular feature type / table.
        Throws:
        IOException
      • update

        protected void update​(SimpleFeatureType featureType,
                              List<AttributeDescriptor> attributes,
                              List<Object> values,
                              Filter filter,
                              Connection cx)
                       throws IOException,
                              SQLException
        Updates an existing feature(s) in the database for a particular feature type / table.
        Throws:
        IOException
        SQLException
      • update

        protected void update​(SimpleFeatureType featureType,
                              AttributeDescriptor[] attributes,
                              Object[] values,
                              Filter filter,
                              Connection cx)
                       throws IOException,
                              SQLException
        Updates an existing feature(s) in the database for a particular feature type / table.
        Throws:
        IOException
        SQLException
      • delete

        protected void delete​(SimpleFeatureType featureType,
                              String fid,
                              Connection cx)
                       throws IOException
        Deletes an existing feature in the database for a particular feature type / fid.
        Throws:
        IOException
      • delete

        protected void delete​(SimpleFeatureType featureType,
                              Filter filter,
                              Connection cx)
                       throws IOException
        Deletes an existing feature(s) in the database for a particular feature type / table.
        Throws:
        IOException
      • getConnection

        public Connection getConnection​(Transaction t)
                                 throws IOException
        Returns a JDBC Connection to the underlying database for the specified GeoTools Transaction. This has two main use cases:
        • Independently accessing the underlying database directly reusing the connection pool contained in the JDBCDataStore
        • Performing some direct access to the database in the same JDBC transaction as the Geotools code
        The connection shall be used in a different way depending on the use case:
        • If the transaction is Transaction.AUTO_COMMIT or if the transaction is not shared with this data store and originating 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
        • 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 Transaction facilities to do so instead
        Parameters:
        t - The GeoTools transaction, can not be null
        Throws:
        IOException
      • getConnection

        protected final Connection getConnection​(JDBCState state)
                                          throws IOException
        Gets a database connection for the specified feature store.
        Throws:
        IOException
      • createConnection

        protected final Connection createConnection()
        Creates a new connection.

        Callers of this method should close the connection when done with it. .

      • releaseConnection

        protected final void releaseConnection​(Connection cx,
                                               JDBCState state)
        Releases an existing connection (paying special attention to Transaction.AUTO_COMMIT.

        If the state is based off the AUTO_COMMIT transaction - close using closeSafe(Connection). Otherwise wait until the transaction itself is closed to close the connection.

      • encodeFID

        protected String encodeFID​(PrimaryKey pkey,
                                   ResultSet rs)
                            throws SQLException,
                                   IOException
        Calls through to:
           encodeFID(pkey, rs, 0);
         
        Throws:
        SQLException
        IOException
      • encodeFID

        protected String encodeFID​(PrimaryKey pkey,
                                   ResultSet rs,
                                   int offset)
                            throws SQLException,
                                   IOException
        Encodes a feature id from a primary key and result set values.

        offset specifies where in the result set to start from when reading values for the primary key.

        Throws:
        SQLException
        IOException
      • encodeFID

        protected static String encodeFID​(List<Object> keyValues)
      • decodeFID

        public static List<Object> decodeFID​(PrimaryKey key,
                                             String FID,
                                             boolean strict)
        Decodes a fid into its components based on a primary key.
        Parameters:
        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.
      • isGenerated

        protected boolean isGenerated​(PrimaryKey pkey)
        Determines if a primary key is made up entirely of column which are generated via an auto-generating column or a sequence.
      • createTableSQL

        protected String createTableSQL​(SimpleFeatureType featureType,
                                        Connection cx)
                                 throws Exception
        Generates a 'CREATE TABLE' sql statement.
        Throws:
        Exception
      • findPrimaryKeyColumnName

        protected String findPrimaryKeyColumnName​(SimpleFeatureType featureType)
      • dropTableSQL

        protected String dropTableSQL​(SimpleFeatureType featureType,
                                      Connection cx)
                               throws Exception
        Generates a 'DROP TABLE' sql statement.
        Throws:
        Exception
      • ensureAuthorization

        protected void ensureAuthorization​(SimpleFeatureType featureType,
                                           Filter filter,
                                           Transaction tx,
                                           Connection cx)
                                    throws IOException,
                                           SQLException
        Ensures that that the specified transaction has access to features specified by a filter.

        If any features matching the filter are locked, and the transaction does not have authorization with respect to the lock, an exception is thrown.

        Parameters:
        featureType - The feature type / table.
        filter - The filters.
        tx - The transaction.
        cx - The database connection.
        Throws:
        IOException
        SQLException
      • ensureAssociationTablesExist

        protected void ensureAssociationTablesExist​(Connection cx)
                                             throws IOException,
                                                    SQLException
        Helper method for creating geometry association table if it does not exist.
        Throws:
        IOException
        SQLException
      • createRelationshipTableSQL

        protected String createRelationshipTableSQL​(Connection cx)
                                             throws SQLException
        Creates the sql for the relationship table.

        This method is only called when isAssociations() is true.

        Throws:
        SQLException
      • createAssociationTableSQL

        protected String createAssociationTableSQL​(Connection cx)
                                            throws SQLException
        Creates the sql for the association table.

        This method is only called when isAssociations() is true.

        Throws:
        SQLException
      • createGeometryTableSQL

        protected String createGeometryTableSQL​(Connection cx)
                                         throws SQLException
        Creates the sql for the geometry table.

        This method is only called when isAssociations() is true.

        Throws:
        SQLException
      • createMultiGeometryTableSQL

        protected String createMultiGeometryTableSQL​(Connection cx)
                                              throws SQLException
        Creates the sql for the multi_geometry table.

        This method is only called when isAssociations() is true.

        Throws:
        SQLException
      • selectRelationshipSQL

        protected String selectRelationshipSQL​(String table,
                                               String column)
                                        throws SQLException
        Creates the sql for the relationship table.

        This method is only called when isAssociations() is true.

        Parameters:
        table - The table of the association
        column - The column of the association
        Throws:
        SQLException
      • selectRelationshipSQLPS

        protected PreparedStatement selectRelationshipSQLPS​(String table,
                                                            String column,
                                                            Connection cx)
                                                     throws SQLException
        Creates the prepared statement for a query against the relationship table.

        This method is only called when isAssociations() is true.

        Parameters:
        table - The table of the association
        column - The column of the association
        Throws:
        SQLException
      • selectAssociationSQL

        protected String selectAssociationSQL​(String fid)
                                       throws SQLException
        Creates the sql for the association table.

        This method is only called when isAssociations() is true.

        Parameters:
        fid - The feature id of the association
        Throws:
        SQLException
      • selectAssociationSQLPS

        protected PreparedStatement selectAssociationSQLPS​(String fid,
                                                           Connection cx)
                                                    throws SQLException
        Creates the prepared statement for the association table.

        This method is only called when isAssociations() is true.

        Parameters:
        fid - The feature id of the association
        Throws:
        SQLException
      • selectGeometrySQL

        protected String selectGeometrySQL​(String gid)
                                    throws SQLException
        Creates the sql for a select from the geometry table.

        This method is only called when isAssociations() is true.

        Parameters:
        gid - The geometry id to select for, may be null
        Throws:
        SQLException
      • selectGeometrySQLPS

        protected PreparedStatement selectGeometrySQLPS​(String gid,
                                                        Connection cx)
                                                 throws SQLException
        Creates the prepared for a select from the geometry table.

        This method is only called when isAssociations() is true.

        Parameters:
        gid - The geometry id to select for, may be null
        Throws:
        SQLException
      • selectMultiGeometrySQL

        protected String selectMultiGeometrySQL​(String gid)
                                         throws SQLException
        Creates the sql for a select from the multi geometry table.

        This method is only called when isAssociations() is true.

        Parameters:
        gid - The geometry id to select for, may be null.
        Throws:
        SQLException
      • selectMultiGeometrySQLPS

        protected PreparedStatement selectMultiGeometrySQLPS​(String gid,
                                                             Connection cx)
                                                      throws SQLException
        Creates the prepared statement for a select from the multi geometry table.

        This method is only called when isAssociations() is true.

        Parameters:
        gid - The geometry id to select for, may be null.
        Throws:
        SQLException
      • createGeometryAssociationTableSQL

        protected String createGeometryAssociationTableSQL​(Connection cx)
                                                    throws SQLException
        Creates the sql for the geometry association table.

        This method is only called when isAssociations() is true.

        Throws:
        SQLException
      • selectGeometryAssociationSQL

        protected String selectGeometryAssociationSQL​(String fid,
                                                      String gid,
                                                      String gname)
                                               throws SQLException
        Creates the sql for a select from the geometry association table.

        Parameters:
        fid - The fid to select for, may be null
        gid - The geometry id to select for, may be null
        gname - The geometry name to select for, may be null
        Throws:
        SQLException
      • selectGeometryAssociationSQLPS

        protected PreparedStatement selectGeometryAssociationSQLPS​(String fid,
                                                                   String gid,
                                                                   String gname,
                                                                   Connection cx)
                                                            throws SQLException
        Creates the prepared statement for a select from the geometry association table.

        Parameters:
        fid - The fid to select for, may be null
        gid - The geometry id to select for, may be null
        gname - The geometry name to select for, may be null
        Throws:
        SQLException
      • selectSQL

        protected String selectSQL​(SimpleFeatureType featureType,
                                   Query query)
                            throws IOException,
                                   SQLException
        Generates a 'SELECT p1, p2, ... FROM ... WHERE ...' statement.
        Parameters:
        featureType - the feature type that the query must return (may contain less attributes than the native one)
        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
        Throws:
        IOException
        SQLException
      • selectJoinSQL

        protected String selectJoinSQL​(SimpleFeatureType featureType,
                                       JoinInfo join,
                                       Query query)
                                throws IOException,
                                       SQLException
        Throws:
        IOException
        SQLException
      • selectSQLPS

        protected PreparedStatement selectSQLPS​(SimpleFeatureType featureType,
                                                Query query,
                                                Connection cx)
                                         throws SQLException,
                                                IOException
        Generates a 'SELECT p1, p2, ... FROM ... WHERE ...' prepared statement.
        Parameters:
        featureType - the feature type that the query must return (may contain less attributes than the native one)
        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
        cx - The database connection to be used to create the prepared statement
        Throws:
        SQLException
        IOException
      • selectJoinSQLPS

        protected PreparedStatement selectJoinSQLPS​(SimpleFeatureType featureType,
                                                    JoinInfo join,
                                                    Query query,
                                                    Connection cx)
                                             throws SQLException,
                                                    IOException
        Throws:
        SQLException
        IOException
      • setPreparedFilterValues

        protected void setPreparedFilterValues​(PreparedStatement ps,
                                               List<FilterToSQL> toSQLs,
                                               Connection cx)
                                        throws SQLException
        Helper method for setting the values of the WHERE class of a prepared statement from a list of PreparedFilterToSQL.
        Throws:
        SQLException
      • setPreparedFilterValues

        public void setPreparedFilterValues​(PreparedStatement ps,
                                            PreparedFilterToSQL toSQL,
                                            int offset,
                                            Connection cx)
                                     throws SQLException
        Helper method for setting the values of the WHERE class of a prepared statement.
        Throws:
        SQLException
      • selectBoundsSQL

        protected String selectBoundsSQL​(SimpleFeatureType featureType,
                                         Query query)
                                  throws SQLException
        Generates a 'SELECT' sql statement which selects bounds.
        Parameters:
        featureType - The feature type / table.
        query - Specifies which features are to be used for the bounds computation (and in particular uses filter, start index and max features)
        Throws:
        SQLException
      • selectBoundsSQLPS

        protected PreparedStatement selectBoundsSQLPS​(SimpleFeatureType featureType,
                                                      Query query,
                                                      Connection cx)
                                               throws SQLException
        Generates a 'SELECT' prepared statement which selects bounds.
        Parameters:
        featureType - The feature type / table.
        query - Specifies which features are to be used for the bounds computation (and in particular uses filter, start index and max features)
        cx - A database connection.
        Throws:
        SQLException
      • selectAggregateSQL

        protected String selectAggregateSQL​(String function,
                                            List<Expression> attributes,
                                            List<Expression> groupByExpressions,
                                            SimpleFeatureType featureType,
                                            Query query,
                                            LimitingVisitor visitor)
                                     throws SQLException,
                                            IOException
        Throws:
        SQLException
        IOException
      • selectAggregateSQLPS

        protected PreparedStatement selectAggregateSQLPS​(String function,
                                                         List<Expression> attributes,
                                                         List<Expression> groupByExpressions,
                                                         SimpleFeatureType featureType,
                                                         Query query,
                                                         LimitingVisitor visitor,
                                                         Connection cx)
                                                  throws SQLException,
                                                         IOException
        Throws:
        SQLException
        IOException
      • encodeGroupByStatement

        protected void encodeGroupByStatement​(List<Expression> groupByExpressions,
                                              StringBuffer sql,
                                              FilterToSQL filterToSQL,
                                              boolean aggregateOnExpression)
        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.
        Parameters:
        groupByExpressions - the group by attributes to be encoded
        sql - the sql query buffer
      • encodeFunction

        protected void encodeFunction​(String function,
                                      Expression expression,
                                      StringBuffer sql,
                                      FilterToSQL filterToSQL)
      • encodeFunction

        protected void encodeFunction​(String function,
                                      List<Expression> expressions,
                                      StringBuffer sql,
                                      FilterToSQL filterToSQL)
      • deleteSQL

        protected String deleteSQL​(SimpleFeatureType featureType,
                                   Filter filter)
                            throws SQLException
        Generates a 'DELETE FROM' sql statement.
        Throws:
        SQLException
      • deleteSQLPS

        protected PreparedStatement deleteSQLPS​(SimpleFeatureType featureType,
                                                Filter filter,
                                                Connection cx)
                                         throws SQLException
        Generates a 'DELETE FROM' prepared statement.
        Throws:
        SQLException
      • insertSQL

        protected String insertSQL​(SimpleFeatureType featureType,
                                   SimpleFeature feature,
                                   KeysFetcher keysFetcher,
                                   Connection cx)
                            throws SQLException,
                                   IOException
        Generates a 'INSERT INFO' sql statement.
        Throws:
        SQLException
        IOException
      • getColumnNames

        protected static LinkedHashSet<String> getColumnNames​(PrimaryKey key)
        Returns the set of the primary key column names. The set is guaranteed to have the same iteration order as the primary key.
      • getGeometrySRID

        protected int getGeometrySRID​(Geometry g,
                                      AttributeDescriptor descriptor)
                               throws IOException
        Looks up the geometry srs by trying a number of heuristics. Returns -1 if all attempts at guessing the srid failed.
        Throws:
        IOException
      • getGeometryDimension

        protected int getGeometryDimension​(Geometry g,
                                           AttributeDescriptor descriptor)
                                    throws IOException
        Looks up the geometry dimension by trying a number of heuristics. Returns 2 if all attempts at guessing the dimension failed.
        Throws:
        IOException
      • getDescriptorSRID

        protected int getDescriptorSRID​(AttributeDescriptor descriptor)
        Extracts the eventual native SRID user property from the descriptor, returns -1 if not found
      • getDescriptorDimension

        protected int getDescriptorDimension​(AttributeDescriptor descriptor)
        Extracts the eventual native dimension user property from the descriptor, returns -1 if not found
      • updateSQL

        protected String updateSQL​(SimpleFeatureType featureType,
                                   AttributeDescriptor[] attributes,
                                   Object[] values,
                                   Filter filter,
                                   Set<String> pkColumnNames)
                            throws IOException,
                                   SQLException
        Generates an 'UPDATE' sql statement.
        Throws:
        IOException
        SQLException
      • updateSQLPS

        protected PreparedStatement updateSQLPS​(SimpleFeatureType featureType,
                                                AttributeDescriptor[] attributes,
                                                Object[] values,
                                                Filter filter,
                                                Set<String> pkColumnNames,
                                                Connection cx)
                                         throws IOException,
                                                SQLException
        Generates an 'UPDATE' prepared statement.
        Throws:
        IOException
        SQLException
      • createFilterToSQL

        public FilterToSQL createFilterToSQL​(SimpleFeatureType featureType)
        Creates a new instance of a filter to sql encoder.

        The featureType 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.

      • createPreparedFilterToSQL

        public PreparedFilterToSQL createPreparedFilterToSQL​(SimpleFeatureType featureType)
        Creates a new instance of a filter to sql encoder to be used in a prepared statement.
      • initializeFilterToSQL

        protected <F extends FilterToSQL> F initializeFilterToSQL​(F toSQL,
                                                                  SimpleFeatureType featureType)
        Helper method to initialize a filter encoder instance.
      • encodeTableName

        public void encodeTableName​(String tableName,
                                    StringBuffer sql,
                                    Hints hints)
                             throws SQLException
        Helper method to encode table name which checks if a schema is set and prefixes the table name with it.
        Throws:
        SQLException
      • encodeAliasedTableName

        public void encodeAliasedTableName​(String tableName,
                                           StringBuffer sql,
                                           Hints hints,
                                           String alias)
                                    throws SQLException
        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
        Throws:
        SQLException
      • encodeTableJoin

        protected void encodeTableJoin​(SimpleFeatureType featureType,
                                       JoinInfo join,
                                       Query query,
                                       StringBuffer sql)
                                throws SQLException
        Helper method to encode the join clause(s) of a query.
        Throws:
        SQLException
      • setGmlProperties

        protected void setGmlProperties​(Geometry g,
                                        String gid,
                                        String name,
                                        String description)
        Helper method for setting the gml:id of a geometry as user data.
      • applyLimitOffset

        public void applyLimitOffset​(StringBuffer sql,
                                     Query query)
        Applies the limit/offset elements to the query if they are specified and if the dialect supports them
        Parameters:
        sql - The sql to be modified
        query - the query that holds the limit and offset parameters
      • closeSafe

        public void closeSafe​(ResultSet rs)
        Utility method for closing a result set.

        This method closed the result set "safely" in that it never throws an exception. Any exceptions that do occur are logged at Level.FINER.

        Parameters:
        rs - The result set to close.
      • closeSafe

        public void closeSafe​(Statement st)
        Utility method for closing a statement.

        This method closed the statement"safely" in that it never throws an exception. Any exceptions that do occur are logged at Level.FINER.

        Parameters:
        st - The statement to close.
      • closeSafe

        public void closeSafe​(Connection cx)
        Utility method for closing a connection.

        This method closed the connection "safely" in that it never throws an exception. Any exceptions that do occur are logged at Level.FINER.

        Parameters:
        cx - The connection to close.
      • finalize

        protected void finalize()
                         throws Throwable
        Overrides:
        finalize in class Object
        Throws:
        Throwable
      • dispose

        public void dispose()
        Description copied from interface: DataAccess
        Disposes of this data store and releases any resource that it is using.

        A DataStore cannot be used after dispose has been called, neither can any data access object it helped create, such as FeatureReader, FeatureSource or FeatureCollection.

        This operation can be called more than once without side effects.

        There is no thread safety assurance associated with this method. For example, client code will have to make sure this method is not called while retrieving/saving data from/to the storage, or be prepared for the consequences.

        Specified by:
        dispose in interface DataAccess<SimpleFeatureType,​SimpleFeature>
        Overrides:
        dispose in class ContentDataStore
      • isGeneralizationRequired

        protected boolean isGeneralizationRequired​(Hints hints,
                                                   GeometryDescriptor gatt)
        Checks if geometry generalization required and makes sense
        Parameters:
        hints - hints hints passed in
        gatt - Geometry attribute descriptor
        Returns:
        true to indicate generalization
      • isSimplificationRequired

        protected boolean isSimplificationRequired​(Hints hints,
                                                   GeometryDescriptor gatt)
        Checks if geometry simplification required and makes sense
        Parameters:
        hints - hints hints passed in
        gatt - Geometry attribute descriptor
        Returns:
        true to indicate simplification
      • encodeGeometryColumn

        protected void encodeGeometryColumn​(GeometryDescriptor gatt,
                                            String prefix,
                                            StringBuffer sql,
                                            Hints hints)
      • buildTransaction

        public Transaction buildTransaction​(Connection cx)
        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 JDBCDataStore.

        Calls to Transaction.commit(), Transaction.rollback() and Transaction.close() will not result in corresponding calls to the provided Connection object.

        Parameters:
        cx - The externally managed connection
      • createIndex

        public void createIndex​(Index index)
                         throws IOException
        Creates a new database index
        Throws:
        IOException
      • dropIndex

        public void dropIndex​(String typeName,
                              String indexName)
                       throws IOException
        Creates a new database index
        Throws:
        IOException
      • getIndexes

        public List<Index> getIndexes​(String typeName)
                               throws IOException
        Lists all indexes associated to the given feature type
        Parameters:
        typeName - Name of the type for which indexes are searched. It's mandatory
        Throws:
        IOException
      • escapeNamePattern

        public String escapeNamePattern​(DatabaseMetaData metaData,
                                        String name)
                                 throws SQLException
        Escapes a name pattern used in e.g. DatabaseMetaData.getColumns(String, String, String, String) when passed in argument is an exact name and not a pattern.

        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.

        Throws:
        SQLException