DataStoreWrapper (Geotools modules 25.2 API)

Object
- DataStoreWrapper

All Implemented Interfaces:

DataAccess<SimpleFeatureType,SimpleFeature>, DataStore

Direct Known Subclasses:

OracleDatastoreWrapper, PostgisDatastoreWrapper, SQLServerDatastoreWrapper
```
public abstract class DataStoreWrapper
extends Object
implements DataStore
```
A data store wrapper around a DataStore object.

Author:

Daniele Romagnoli, GeoSolutions SAS @TODO move that class on gt-transform once ready

Field Summary

Fields
Modifier and Type	Field and Description
`protected File`	`auxiliaryFolder` Auxiliary folder which contains properties file with mapping information
`protected static String`	`COORDINATE_REFERENCE_SYSTEM`
`protected DataStore`	`datastore` The underlying datastore
`protected static String`	`HIDDEN_FOLDER`
`protected static Logger`	`LOGGER`
`protected static String`	`MAPPEDNAME`
`protected Map<Name,FeatureTypeMapper>`	`mapping` Mapping between typeNames and FeatureTypeMapper
`protected static String`	`NAME`
`protected static String`	`SCHEMA`

Constructor Summary

Constructors
Constructor and Description
`DataStoreWrapper(DataStore datastore, String auxFolderPath)` Base constructor
`DataStoreWrapper(DataStore datastore, String auxFolderPath, String subFolderName)` Base constructor with custom hidden folder

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`createSchema(SimpleFeatureType featureType)` Creates storage for a new `featureType`.
`void`	`dispose()` Disposes of this data store and releases any resource that it is using.
`FeatureReader<SimpleFeatureType,SimpleFeature>`	`getFeatureReader(Query query, Transaction transaction)` Gets a `FeatureReader` for features selected by the given `Query`.
`SimpleFeatureSource`	`getFeatureSource(Name typeName)` Gets a `SimpleFeatureSource` for features of the type specified by a qualified name (namespace plus type name).
`SimpleFeatureSource`	`getFeatureSource(String typeName)` Gets a `SimpleFeatureSource` for features of the specified type.
`protected FeatureTypeMapper`	`getFeatureTypeMapper(Properties props)` Return a specific `FeatureTypeMapper` by parsing mapping properties contained within the specified `Properties` object
`protected abstract FeatureTypeMapper`	`getFeatureTypeMapper(SimpleFeatureType featureType)` Return a specific `FeatureTypeMapper` instance on top of an input featureType
`FeatureWriter<SimpleFeatureType,SimpleFeature>`	`getFeatureWriter(String typeName, Filter filter, Transaction transaction)` Gets a `FeatureWriter` to modify features in this `DataStore`.
`FeatureWriter<SimpleFeatureType,SimpleFeature>`	`getFeatureWriter(String typeName, Transaction transaction)` Gets a `FeatureWriter` to modify features in this `DataStore`.
`FeatureWriter<SimpleFeatureType,SimpleFeature>`	`getFeatureWriterAppend(String typeName, Transaction transaction)` Gets a `FeatureWriter` that can add new features to the `DataStore`.
`ServiceInfo`	`getInfo()` Information about this service.
`LockingManager`	`getLockingManager()` Retrieve a per featureID based locking service from this `DataStore`.
`List<Name>`	`getNames()` Names of the available Resources.
`SimpleFeatureType`	`getSchema(Name name)` Description of the named resource.
`SimpleFeatureType`	`getSchema(String typeName)` Gets the type information (schema) for the specified feature type.
`String[]`	`getTypeNames()` Gets the names of feature types available in this `DataStore`.
`void`	`removeSchema(Name typeName)` Used to permanently remove a schema from the underlying storage This functionality is similar to an "drop table" statement in SQL.
`void`	`removeSchema(String typeName)` Used to permanently remove a schema from the underlying storage This functionality is similar to an "drop table" statement in SQL.
`protected void`	`storeMapper(FeatureTypeMapper mapper)` Store the `FeatureTypeMapper` instance
`protected void`	`storeProperties(Properties properties, String typeName)` Store the properties on disk
`protected SimpleFeatureSource`	`transformFeatureStore(SimpleFeatureStore source, FeatureTypeMapper mapper)`
`void`	`updateSchema(Name typeName, SimpleFeatureType featureType)` Used to update a schema in place.
`void`	`updateSchema(String typeName, SimpleFeatureType featureType)` Applies a new schema to the given feature type.

Methods inherited from class Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - HIDDEN_FOLDER
```
protected static final String HIDDEN_FOLDER
```
    See Also:
    
    Constant Field Values
  - NAME
```
protected static final String NAME
```
    See Also:
    
    Constant Field Values
  - MAPPEDNAME
```
protected static final String MAPPEDNAME
```
    See Also:
    
    Constant Field Values
  - SCHEMA
```
protected static final String SCHEMA
```
    See Also:
    
    Constant Field Values
  - COORDINATE_REFERENCE_SYSTEM
```
protected static final String COORDINATE_REFERENCE_SYSTEM
```
    See Also:
    
    Constant Field Values
  - LOGGER
```
protected static final Logger LOGGER
```
  - auxiliaryFolder
```
protected File auxiliaryFolder
```
    Auxiliary folder which contains properties file with mapping information
  - datastore
```
protected final DataStore datastore
```
    The underlying datastore
  - mapping
```
protected final Map<Name,FeatureTypeMapper> mapping
```
    Mapping between typeNames and FeatureTypeMapper
- Constructor Detail
  - DataStoreWrapper
```
public DataStoreWrapper(DataStore datastore,
                        String auxFolderPath)
```
    Base constructor
  - DataStoreWrapper
```
public DataStoreWrapper(DataStore datastore,
                        String auxFolderPath,
                        String subFolderName)
```
    Base constructor with custom hidden folder
- Method Detail
  - getInfo
```
public ServiceInfo getInfo()
```
    Description copied from interface: DataAccess
    
    Information about this service.
    This method offers access to a summary of header or metadata information describing the service. Subclasses may return a specific ServiceInfo instance that has additional information (such as FilterCapabilities).
    
    Specified by:
    
    getInfo in interface DataAccess<SimpleFeatureType,SimpleFeature>
    
    Returns:
    
    SeviceInfo
  - createSchema
```
public void createSchema(SimpleFeatureType featureType)
                  throws IOException
```
    Description copied from interface: DataAccess
    
    Creates storage for a new featureType.
    The provided featureType we be accessable by the typeName provided by featureType.getTypeName().
    
    Specified by:
    
    createSchema in interface DataAccess<SimpleFeatureType,SimpleFeature>
    
    Parameters:
    
    featureType - FetureType to add to DataStore
    
    Throws:
    
    IOException - If featureType cannot be created
  - storeProperties
```
protected void storeProperties(Properties properties,
                               String typeName)
```
    Store the properties on disk
  - updateSchema
```
public void updateSchema(Name typeName,
                         SimpleFeatureType featureType)
                  throws IOException
```
    Description copied from interface: DataAccess
    
    Used to update a schema in place.
    This functionality is similar to an "alter table" statement in SQL. Implementation is optional; it may not be supported by all servers or files.
    
    Specified by:
    
    updateSchema in interface DataAccess<SimpleFeatureType,SimpleFeature>
    
    Throws:
    
    IOException - if the operation failed
  - getNames
```
public List<Name> getNames()
                    throws IOException
```
    Description copied from interface: DataAccess
    
    Names of the available Resources.
    For additional information please see getInfo( Name ) and getSchema( Name ).
    
    Specified by:
    
    getNames in interface DataAccess<SimpleFeatureType,SimpleFeature>
    
    Returns:
    
    Names of the available contents.
    
    Throws:
    
    IOException
  - getSchema
```
public SimpleFeatureType getSchema(Name name)
                            throws IOException
```
    Description copied from interface: DataAccess
    
    Description of the named resource.
    The FeatureType returned describes the contents being published. For additional metadata please review getInfo( Name ).
    
    Specified by:
    
    getSchema in interface DataAccess<SimpleFeatureType,SimpleFeature>
    
    Parameters:
    
    name - Type name a the resource from getNames()
    
    Returns:
    
    Description of the FeatureType being made avaialble
    
    Throws:
    
    IOException
  - getSchema
```
public SimpleFeatureType getSchema(String typeName)
                            throws IOException
```
    Description copied from interface: DataStore
    
    Gets the type information (schema) for the specified feature type.
    
    Specified by:
    
    getSchema in interface DataStore
    
    Parameters:
    
    typeName - the feature type name
    
    Returns:
    
    the requested feature type
    
    Throws:
    
    IOException - if typeName is not available
  - 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>
  - updateSchema
```
public void updateSchema(String typeName,
                         SimpleFeatureType featureType)
                  throws IOException
```
    Description copied from interface: DataStore
    
    Applies a new schema to the given feature type. This can be used to add or remove properties. The resulting update will be persistent.
    
    Specified by:
    
    updateSchema in interface DataStore
    
    Parameters:
    
    typeName - name of the feature type to update
    
    featureType - the new schema to apply
    
    Throws:
    
    IOException - on error
  - removeSchema
```
public void removeSchema(Name typeName)
                  throws IOException
```
    Description copied from interface: DataAccess
    
    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 DataAccess<SimpleFeatureType,SimpleFeature>
    
    Throws:
    
    IOException - if the operation failed
  - 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
    
    Throws:
    
    IOException - if the operation failed
  - getTypeNames
```
public String[] getTypeNames()
                      throws IOException
```
    Description copied from interface: DataStore
    
    Gets the names of feature types available in this DataStore. Please note that this is not guaranteed to return a list of unique names since the same unqualified name may be present in separate namespaces within the DataStore.
    
    Specified by:
    
    getTypeNames in interface DataStore
    
    Returns:
    
    names of feature types available in this DataStore
    
    Throws:
    
    IOException - if data access errors occur
  - getFeatureSource
```
public SimpleFeatureSource getFeatureSource(String typeName)
                                     throws IOException
```
    Description copied from interface: DataStore
    Gets a SimpleFeatureSource for features of the specified type. SimpleFeatureSource provides a high-level API for feature operations.
    The resulting SimpleFeatureSource may implment more functionality as in this example:
```
 SimpleFeatureSource fsource = dataStore.getFeatureSource("roads");
 if (fsource instanceof SimpleFeatureStore) {
     // we have write access to the feature data
     SimpleFeatureStore fstore = (SimpleFeatureStore) fs;
 }
 else {
     // System.out.println("We do not have write access to roads");
 }
 
```
    Specified by:
    
    getFeatureSource in interface DataStore
    
    Parameters:
    
    typeName - the feature type
    
    Returns:
    
    a SimpleFeatureSource (or possibly a subclass) providing operations for features of the specified type
    
    Throws:
    
    IOException - if data access errors occur
    
    See Also:
    
    SimpleFeatureSource, SimpleFeatureStore
  - getFeatureSource
```
public SimpleFeatureSource getFeatureSource(Name typeName)
                                     throws IOException
```
    Description copied from interface: DataStore
    
    Gets a SimpleFeatureSource for features of the type specified by a qualified name (namespace plus type name).
    
    Specified by:
    
    getFeatureSource in interface DataAccess<SimpleFeatureType,SimpleFeature>
    
    Specified by:
    
    getFeatureSource in interface DataStore
    
    Parameters:
    
    typeName - the qualified name of the feature type
    
    Returns:
    
    a SimpleFeatureSource (or possibly a subclass) providing operations for features of the specified type
    
    Throws:
    
    IOException - if data access errors occur
    
    See Also:
    
    DataStore.getFeatureSource(String), SimpleFeatureSource, SimpleFeatureStore
  - transformFeatureStore
```
protected SimpleFeatureSource transformFeatureStore(SimpleFeatureStore source,
                                                    FeatureTypeMapper mapper)
                                             throws IOException
```
    Throws:
    
    IOException
  - getFeatureReader
```
public FeatureReader<SimpleFeatureType,SimpleFeature> getFeatureReader(Query query,
                                                                       Transaction transaction)
                                                                throws IOException
```
    Description copied from interface: DataStore
    
    Gets a FeatureReader for features selected by the given Query. FeatureReader provies an iterator-style API to feature data.
    The Query provides the schema for the form of the returned features as well as a Filter to constrain the features available via the reader.
    The Transaction can be used to externalize the state of the DataStore. Examples of this include a JDBCDataStore sharing a connection for use across several FeatureReader requests; and a ShapefileDataStore redirecting requests to an alternate file during the course of a Transaction.
    
    Specified by:
    
    getFeatureReader in interface DataStore
    
    Parameters:
    
    query - a query providing the schema and constraints for features that the reader will return
    
    transaction - a transaction that this reader will operate against
    
    Returns:
    
    an instance of FeatureReader
    
    Throws:
    
    IOException - if data access errors occur
  - getFeatureWriter
```
public FeatureWriter<SimpleFeatureType,SimpleFeature> getFeatureWriter(String typeName,
                                                                       Filter filter,
                                                                       Transaction transaction)
                                                                throws IOException
```
    Description copied from interface: DataStore
    
    Gets a FeatureWriter to modify features in this DataStore. FeatureWriter provides an iterator style API to features.
    The returned writer does not allow features to be added.
    
    Specified by:
    
    getFeatureWriter in interface DataStore
    
    Parameters:
    
    typeName - the type name for features that will be accessible
    
    filter - defines additional constraints on the features that will be accessible
    
    transaction - the transaction that the returned writer operates against
    
    Returns:
    
    an instance of FeatureWriter
    
    Throws:
    
    IOException - if data access errors occur
    
    See Also:
    
    DataStore.getFeatureWriterAppend(String, Transaction)
  - getFeatureWriter
```
public FeatureWriter<SimpleFeatureType,SimpleFeature> getFeatureWriter(String typeName,
                                                                       Transaction transaction)
                                                                throws IOException
```
    Description copied from interface: DataStore
    
    Gets a FeatureWriter to modify features in this DataStore. FeatureWriter provides an iterator style API to features.
    The returned writer does not allow features to be added.
    
    Specified by:
    
    getFeatureWriter in interface DataStore
    
    Parameters:
    
    typeName - the type name for features that will be accessible
    
    transaction - the transaction that the returned writer operates against
    
    Returns:
    
    an instance of FeatureWriter
    
    Throws:
    
    IOException - if data access errors occur
    
    See Also:
    
    DataStore.getFeatureWriterAppend(String, Transaction)
  - getFeatureWriterAppend
```
public FeatureWriter<SimpleFeatureType,SimpleFeature> getFeatureWriterAppend(String typeName,
                                                                             Transaction transaction)
                                                                      throws IOException
```
    Description copied from interface: DataStore
    
    Gets a FeatureWriter that can add new features to the DataStore.
    The FeatureWriter will return false when its hasNext() method is called, but next() can be used to acquire new features.
    
    Specified by:
    
    getFeatureWriterAppend in interface DataStore
    
    Parameters:
    
    typeName - name of the feature type for which features will be added
    
    transaction - the transaction to operate against
    
    Returns:
    
    an instance of FeatureWriter that can only be used to append new features
    
    Throws:
    
    IOException - if data access errors occur
  - getLockingManager
```
public LockingManager getLockingManager()
```
    Description copied from interface: DataStore
    
    Retrieve a per featureID based locking service from this DataStore.
    
    Specified by:
    
    getLockingManager in interface DataStore
    
    Returns:
    
    an instance of LockingManager; or null if locking is handled by the DataStore in a different fashion
  - storeMapper
```
protected void storeMapper(FeatureTypeMapper mapper)
```
    Store the FeatureTypeMapper instance
  - getFeatureTypeMapper
```
protected FeatureTypeMapper getFeatureTypeMapper(Properties props)
                                          throws Exception
```
    Return a specific FeatureTypeMapper by parsing mapping properties contained within the specified Properties object
    
    Throws:
    
    Exception
  - getFeatureTypeMapper
```
protected abstract FeatureTypeMapper getFeatureTypeMapper(SimpleFeatureType featureType)
                                                   throws Exception
```
    Return a specific FeatureTypeMapper instance on top of an input featureType
    
    Throws:
    
    Exception

Class DataStoreWrapper

Field Summary

Constructor Summary

Method Summary

Methods inherited from class Object

Field Detail

HIDDEN_FOLDER

NAME

MAPPEDNAME

SCHEMA

COORDINATE_REFERENCE_SYSTEM

LOGGER

auxiliaryFolder

datastore

mapping

Constructor Detail

DataStoreWrapper

DataStoreWrapper

Method Detail

getInfo

createSchema

storeProperties

updateSchema

getNames

getSchema

getSchema

dispose

updateSchema

removeSchema

removeSchema

getTypeNames

getFeatureSource

getFeatureSource

transformFeatureStore

getFeatureReader

getFeatureWriter

getFeatureWriter

getFeatureWriterAppend

getLockingManager

storeMapper

getFeatureTypeMapper

getFeatureTypeMapper