Package org.geotools.data.store

Class ContentDataStore

Object

ContentDataStore

All Implemented Interfaces:

DataAccess<SimpleFeatureType,SimpleFeature>, DataStore

Direct Known Subclasses:

CSVDataStore, GeoJSONDataStore, GraticuleDataStore, JDBCDataStore, MBTilesDataStore, MemoryDataStore, MongoDataStore, OGRDataStore, PropertyDataStore, ShapefileDataStore, STACDataStore, VectorMosaicStore, VPFFileStore, VPFLibrary, WFSDataStore

public abstract class ContentDataStore
extends Object
implements DataStore

Abstract base class for data stores.

A datastore contains a set of entries (ContentEntry). Each entry corresponds to a "real world dataset". For instance, a shapefile datastore would contain a single entry which would represent the shapefile on disk. A postgis datastore could contain many entries, one for each table in the database.

Each entry is identified by a name (Name). The name can be qualified with a namespace uri, or unqualified (in which the namespace uri is null). An example of a datastore that might use qualified names is WFS, where in each entry corresponds to a WFS "Feature Type", which have namespace qualified name. Other datastores (such as databases) use unqualified names.

When entry names of a datastore are unqualified, a default namespace uri can be set "globally" on the datastore itself, see setNamespaceURI(String). When this value is set, unqualified entry names are implicitly qualified with the global namespace uri.

Subclasses

At a minimum subclasses must implement the following methods:

• createTypeNames()
• createFeatureSource(ContentEntry)

The following methods may also be overriden:

• createContentState(ContentEntry)

The following methods may be overriden but only to narrow the return type to a specific subclass of ContentFeatureSource.

• getFeatureSource(String)
• getFeatureSource(String, Transaction)
• getFeatureSource(Name, Transaction)

Author:

Jody Garnett, Refractions Research Inc., Justin Deoliveira, The Open Planning Project, Niels Charlier

Field Summary

Fields

Modifier and Type	Field	Description
protected DataStoreFactorySpi	dataStoreFactory	factory used to create the datastore
protected Map<Name,ContentEntry>	entries	name, entry map
protected FeatureFactory	featureFactory	Factory used to create features
protected FilterFactory	filterFactory	Factory used to create filters
protected GeometryFactory	geometryFactory	Factory used to create geometries
static String	JOINED_FEATURE_TYPE	When joining feature types, the UserData of the joined attribute descriptors will contain their full feature type under this key
protected LockingManager	lockingManager	locking manager
protected Logger	LOGGER	logger
protected String	namespaceURI	namespace uri of the datastore itself, or default namespace
protected FeatureTypeFactory	typeFactory	Factory used to create feature types
protected static int	WRITER_ADD	Flag writer for adding new content
protected static int	WRITER_COMMIT	Flag writer for commit (AUTO_COMMIT with no events)
protected static int	WRITER_UPDATE	Flag writer for updating content in place

Constructor Summary

Constructors

Constructor	Description
ContentDataStore()

Method Summary

Modifier and Type	Method	Description
protected ContentState	createContentState(ContentEntry entry)	Instantiates a new content state for the entry.
protected abstract ContentFeatureSource	createFeatureSource(ContentEntry entry)	Instantiates new feature source for the entry.
void	createSchema(SimpleFeatureType featureType)	Creates a new schema in the datastore.
protected abstract List<Name>	createTypeNames()	Creates a set of qualified names corresponding to the types that the datastore provides.
void	dispose()	Disposes of this data store and releases any resource that it is using.
protected ContentEntry	ensureEntry(Name name)	Helper method to look up an entry in the datastore which throws an IOException in the event that the entry does not exist.
protected ContentFeatureStore	ensureFeatureStore(String typeName, Transaction tx)	Helper method which gets a feature source ensuring that it is a feature store as well.
protected ContentEntry	entry(Name name)	Helper method to look up an entry in the datastore.
DataStoreFactorySpi	getDataStoreFactory()	Returns the factory used to create the data store.
ContentEntry	getEntry(Name name)	Returns the entry for a specified name, or null if no such entry exists.
FeatureFactory	getFeatureFactory()	The factory used to create features.
FeatureReader<SimpleFeatureType,SimpleFeature>	getFeatureReader(Query query, Transaction tx)	Returns a feature reader for the specified query and transaction.
ContentFeatureSource	getFeatureSource(String typeName)	Returns the feature source matching the specified name.
ContentFeatureSource	getFeatureSource(String typeName, Transaction tx)	Returns the feature source matching the specified name and explicitly specifies a transaction.
SimpleFeatureSource	getFeatureSource(Name typeName)	Delegates to getFeatureSource(Name, Transaction)
ContentFeatureSource	getFeatureSource(Name typeName, Transaction tx)	Returns the feature source matching the specified name and explicitly specifies a transaction.
FeatureTypeFactory	getFeatureTypeFactory()	The factory used to create feature types.
FeatureWriter<SimpleFeatureType,SimpleFeature>	getFeatureWriter(String typeName, Transaction tx)	Returns a feature writer for the specified type name and transaction.
FeatureWriter<SimpleFeatureType,SimpleFeature>	getFeatureWriter(String typeName, Filter filter, Transaction tx)	Returns a feature writer for the specified query and transaction.
FeatureWriter<SimpleFeatureType,SimpleFeature>	getFeatureWriterAppend(String typeName, Transaction tx)	Returns an appending feature writer for the specified type name and transaction.
FilterFactory	getFilterFactory()	The factory used to create filters.
GeometryFactory	getGeometryFactory()	The factory used to create geometries.
ServiceInfo	getInfo()	Information about this service.
LockingManager	getLockingManager()	Retrieve a per featureID based locking service from this DataStore.
Logger	getLogger()	The logger for the datastore.
List<Name>	getNames()	Returns the same list of names than getTypeNames() meaning the returned Names have no namespace set.
String	getNamespaceURI()	The namespace uri of the datastore.
SimpleFeatureType	getSchema(String typeName)	Returns the feature type or schema matching the specified name.
SimpleFeatureType	getSchema(Name name)	Delegates to getSchema(String) with name.getLocalPart()
String[]	getTypeNames()	Returns the names of all entries or types provided by the datastore.
protected Name	name(String typeName)	Helper method to wrap a non-qualified name.
protected void	removeEntry(Name name)	Helper method to remove an entry from the cached entry map.
void	removeSchema(String typeName)	Used to permanently remove a schema from the underlying storage
void	removeSchema(Name typeName)	Used to permanently remove a schema from the underlying storage
void	setDataStoreFactory(DataStoreFactorySpi dataStoreFactory)	Sets the data store factory used to create the datastore.
void	setFeatureFactory(FeatureFactory featureFactory)	Sets the factory used to create features.
void	setFeatureTypeFactory(FeatureTypeFactory typeFactory)	Sets the factory used to create feature types.
void	setFilterFactory(FilterFactory filterFactory)	Sets the factory used to create filters.
void	setGeometryFactory(GeometryFactory geometryFactory)	Sets the factory used to create geometries.
void	setNamespaceURI(String namespaceURI)	Sets the namespace uri of the datastore.
void	updateSchema(String typeName, SimpleFeatureType featureType)	Applies a new schema to the given feature type.
void	updateSchema(Name typeName, SimpleFeatureType featureType)	Delegates to updateSchema(String, SimpleFeatureType) with name.getLocalPart()

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

JOINED_FEATURE_TYPE

public static final String JOINED_FEATURE_TYPE

When joining feature types, the UserData of the joined attribute descriptors will contain their full feature type under this key

See Also:

Constant Field Values

WRITER_ADD

protected static final int WRITER_ADD

Flag writer for adding new content

See Also:

Constant Field Values

WRITER_UPDATE

protected static final int WRITER_UPDATE

Flag writer for updating content in place

See Also:

Constant Field Values

WRITER_COMMIT

protected static final int WRITER_COMMIT

Flag writer for commit (AUTO_COMMIT with no events)

See Also:

Constant Field Values

entries

protected final Map<Name,ContentEntry> entries

name, entry map

LOGGER

protected final Logger LOGGER

logger

typeFactory

protected FeatureTypeFactory typeFactory

Factory used to create feature types

featureFactory

protected FeatureFactory featureFactory

Factory used to create features

filterFactory

protected FilterFactory filterFactory

Factory used to create filters

geometryFactory

protected GeometryFactory geometryFactory

Factory used to create geometries

namespaceURI

protected String namespaceURI

namespace uri of the datastore itself, or default namespace

lockingManager

protected LockingManager lockingManager

locking manager

dataStoreFactory

protected DataStoreFactorySpi dataStoreFactory

factory used to create the datastore

Constructor Detail

ContentDataStore

public ContentDataStore()

Method Detail

getFeatureTypeFactory

public FeatureTypeFactory getFeatureTypeFactory()

The factory used to create feature types.

setFeatureTypeFactory

public void setFeatureTypeFactory(FeatureTypeFactory typeFactory)

Sets the factory used to create feature types.

setFeatureFactory

public void setFeatureFactory(FeatureFactory featureFactory)

Sets the factory used to create features.

getFilterFactory

public FilterFactory getFilterFactory()

The factory used to create filters.

getFeatureFactory

public FeatureFactory getFeatureFactory()

The factory used to create features.

setFilterFactory

public void setFilterFactory(FilterFactory filterFactory)

Sets the factory used to create filters.

getGeometryFactory

public GeometryFactory getGeometryFactory()

The factory used to create geometries.

setGeometryFactory

public void setGeometryFactory(GeometryFactory geometryFactory)

Sets the factory used to create geometries.

getDataStoreFactory

public DataStoreFactorySpi getDataStoreFactory()

Returns the factory used to create the data store.

Returns:

The data store factory, possibly null.

setDataStoreFactory

public void setDataStoreFactory(DataStoreFactorySpi dataStoreFactory)

Sets the data store factory used to create the datastore.

WARNING: This property should only be set in cases where the datastore factory is stateless and does not maintain any references to created datastores. Setting this property in such a case will result in a memory leak.

getNamespaceURI

public String getNamespaceURI()

The namespace uri of the datastore.

Returns:

The namespace uri, may be null.

setNamespaceURI

public void setNamespaceURI(String namespaceURI)

Sets the namespace uri of the datastore.

This will be used to qualify the entries or types of the datastore.

Parameters:

namespaceURI - The namespace uri, may be null.

getLogger

public Logger getLogger()

The logger for the datastore.

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

getTypeNames

public final String[] getTypeNames()
                            throws IOException

Returns the names of all entries or types provided by the datastore.

This method is marked final and delegates to createTypeNames(), which subclasses are intended to implement.

Specified by:

getTypeNames in interface DataStore

Returns:

names of feature types available in this DataStore

Throws:

IOException - if data access errors occur

See Also:

DataStore.getTypeNames()

createSchema

public void createSchema(SimpleFeatureType featureType)
                  throws IOException

Creates a new schema in the datastore.

This implementation throws aUnsupportedOperationException. Subclasses should override to support schema creation.

Specified by:

createSchema in interface DataAccess<SimpleFeatureType,SimpleFeature>

Parameters:

featureType - FetureType to add to DataStore

Throws:

IOException - If featureType cannot be created

See Also:

DataAccess.createSchema(FeatureType)

getSchema

public final SimpleFeatureType getSchema(String typeName)
                                  throws IOException

Returns the feature type or schema matching the specified name.

This method calls through to getFeatureSource(typeName).getSchema()

Specified by:

getSchema in interface DataStore

Parameters:

typeName - the feature type name

Returns:

the requested feature type

Throws:

IOException - if typeName is not available

See Also:

DataStore.getSchema(String)

getFeatureSource

public ContentFeatureSource getFeatureSource(String typeName)
                                      throws IOException

Returns the feature source matching the specified name.

Subclasses should not implement this method. However overriding in order to perform a type narrowing to a subclasses of ContentFeatureSource is acceptable.

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:

DataStore.getFeatureSource(String)

getFeatureSource

public ContentFeatureSource getFeatureSource(String typeName,
                                             Transaction tx)
                                      throws IOException

Returns the feature source matching the specified name and explicitly specifies a transaction.

Subclasses should not implement this method. However overriding in order to perform a type narrowing to a subclasses of ContentFeatureSource is acceptable.

Throws:

IOException

See Also:

DataStore.getFeatureSource(String)

getFeatureSource

public ContentFeatureSource getFeatureSource(Name typeName,
                                             Transaction tx)
                                      throws IOException

Returns the feature source matching the specified name and explicitly specifies a transaction.

Subclasses should not implement this method. However overriding in order to perform a type narrowing to a subclasses of ContentFeatureSource is acceptable.

Throws:

IOException

See Also:

DataStore.getFeatureSource(String)

getFeatureReader

public FeatureReader<SimpleFeatureType,SimpleFeature> getFeatureReader(Query query,
                                                                             Transaction tx)
                                                                      throws IOException

Returns a feature reader for the specified query and transaction.

This method is not intended to be overridden and is marked final. This implementation delegates to FeatureCollection and wraps an iterator in a FeatureReader.

Specified by:

getFeatureReader in interface DataStore

Parameters:

query - a query providing the schema and constraints for features that the reader will return

tx - 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 tx)
                                                                      throws IOException

Returns a feature writer for the specified query and transaction.

This method is not intended to be overridden and is marked final. This implementation delegates to FeatureCollection and wraps an iterator in a FeatureWriter.

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

tx - 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)

ensureFeatureStore

protected final ContentFeatureStore ensureFeatureStore(String typeName,
                                                       Transaction tx)
                                                throws IOException

Helper method which gets a feature source ensuring that it is a feature store as well. If not it throws an IOException.

Parameters:

typeName - The name of the feature source.

tx - A transaction handle.

Throws:

IOException - If the feature source is not a store.

getFeatureWriter

public final FeatureWriter<SimpleFeatureType,SimpleFeature> getFeatureWriter(String typeName,
                                                                                   Transaction tx)
                                                                            throws IOException

Returns a feature writer for the specified type name and transaction.

This method is convenience for getFeatureWriter(typeName,Filter.INCLUDE,tx).

Specified by:

getFeatureWriter in interface DataStore

Parameters:

typeName - the type name for features that will be accessible

tx - 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 final FeatureWriter<SimpleFeatureType,SimpleFeature> getFeatureWriterAppend(String typeName,
                                                                                         Transaction tx)
                                                                                  throws IOException

Returns an appending feature writer for the specified type name and transaction.

This method is not intended to be overridden and is marked final. This implementation delegates to FeatureCollection and wraps an iterator in a FeatureWriter.

Specified by:

getFeatureWriterAppend in interface DataStore

Parameters:

typeName - name of the feature type for which features will be added

tx - 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 final 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

updateSchema

public final 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

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>

getEntry

public ContentEntry getEntry(Name name)

Returns the entry for a specified name, or null if no such entry exists.

createContentState

protected ContentState createContentState(ContentEntry entry)

Instantiates a new content state for the entry.

Subclasses may override this method to return a specific subclass of ContentState.

Parameters:

entry - The entry.

Returns:

A new instance of ContentState for the entry.

name

protected final Name name(String typeName)

Helper method to wrap a non-qualified name.

entry

protected final ContentEntry entry(Name name)
                            throws IOException

Helper method to look up an entry in the datastore.

This method will create a new instance of ContentEntry if one does not exist.

In the event that the name does not map to an entry and one cannot be created null will be returned. Note that #ensureEntry(TypeName) will throw an exception in this case.

Parameters:

name - The name of the entry.

Returns:

The entry, or null if it does not exist.

Throws:

IOException

ensureEntry

protected final ContentEntry ensureEntry(Name name)
                                  throws IOException

Helper method to look up an entry in the datastore which throws an IOException in the event that the entry does not exist.

Parameters:

name - The name of the entry.

Returns:

The entry.

Throws:

IOException - If the entry does not exist, or if there was an error looking it up.

removeEntry

protected final void removeEntry(Name name)

Helper method to remove an entry from the cached entry map.

Parameters:

name - The name of the entry.

createTypeNames

protected abstract List<Name> createTypeNames()
                                       throws IOException

Creates a set of qualified names corresponding to the types that the datastore provides.

Namespaces may be left null for data stores which do not support namespace qualified type names.

Returns:

A list of Name.

Throws:

IOException - Any errors occuring connecting to data.

createFeatureSource

protected abstract ContentFeatureSource createFeatureSource(ContentEntry entry)
                                                     throws IOException

Instantiates new feature source for the entry.

Subclasses should override this method to return a specific subclass of ContentFeatureSource.

Parameters:

entry - The entry.

Returns:

An new instance of ContentFeatureSource for the entry.

Throws:

IOException

getFeatureSource

public SimpleFeatureSource getFeatureSource(Name typeName)
                                     throws IOException

Delegates to getFeatureSource(Name, Transaction)

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

Since:

2.5

See Also:

DataAccess.getFeatureSource(Name)

getNames

public List<Name> getNames()
                    throws IOException

Returns the same list of names than getTypeNames() meaning the returned Names have no namespace set.

Specified by:

getNames in interface DataAccess<SimpleFeatureType,SimpleFeature>

Returns:

Names of the available contents.

Throws:

IOException

Since:

2.5

See Also:

DataAccess.getNames()

getSchema

public SimpleFeatureType getSchema(Name name)
                            throws IOException

Delegates to getSchema(String) with name.getLocalPart()

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

Since:

2.5

See Also:

DataAccess.getSchema(Name)

updateSchema

public void updateSchema(Name typeName,
                         SimpleFeatureType featureType)
                  throws IOException

Delegates to updateSchema(String, SimpleFeatureType) with name.getLocalPart()

Specified by:

updateSchema in interface DataAccess<SimpleFeatureType,SimpleFeature>

Throws:

IOException - if the operation failed

Since:

2.5

See Also:

DataAccess.getFeatureSource(Name)

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

See Also:

DataAccess.removeSchema(Name)

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

See Also:

DataStore.removeSchema(String)