|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
ObjectJDBC1DataStore
public abstract class JDBC1DataStore
Abstract class for JDBC based DataStore implementations.
This class provides a default implementation of a JDBC data store. Support for vendor specific JDBC data stores can be easily added to Geotools by subclassing this class and overriding the hooks provided.
At a minimum subclasses should implement the following methods:
buildAttributeType(ResultSet)
-
This should be overriden to construct an attribute type that represents any
column types not supported by the default implementation, such as geometry
columns. getGeometryAttributeIO(AttributeDescriptor, QueryData)
- Should be overriden to
provide a way to read/write geometries into the format of the database Additionally subclasses can optionally override the following:
buildFIDMapperFactory(JDBCDataStoreConfig)
method, and eventually disallow
user overrides by throwing an UnsupportedOperationException
in the
setFidMapperFactory()
method.
allowTable
- Used to determine whether a
table name should be exposed as a feature type. determineSRID
- Used to determine
the SpatialReference ID of a geometry column in a table. buildSQLQuery()
- Sub classes can override this to build a custom SQL query.
getResultSetType
if the standard
result set type is not satisfactory/does not work with a normal FORWARD_ONLY
resultset type getConcurrency
to set the level of
concurrency for the result set used to read/write the database Additionally subclasses may want to set the value of:
Field Summary | |
---|---|
protected boolean |
allowWriteOnVolatileFIDs
When true, writes are allowed also on tables with volatile FID mappers. |
protected JDBCDataStoreConfig |
config
|
FeatureListenerManager |
listenerManager
Manages listener lists for FeatureSource |
protected static Logger |
LOGGER
The logger for the filter module. |
protected String |
sqlNameEscape
The character(s) to surround schema, table and column names an SQL query to support mixed-case and non-English names |
protected int |
transactionIsolation
The transaction isolation level to use in a transaction. |
static Map |
TYPE_MAPPINGS
Maps SQL types to Java classes. |
protected FeatureTypeHandler |
typeHandler
|
Constructor Summary | |
---|---|
JDBC1DataStore(JDBCDataStoreConfig config)
Construct a JDBCDataStore with ConnectionPool and associated configuration. |
Method Summary | |
---|---|
protected boolean |
allowTable(String tablename)
Provides a hook for sub classes to filter out specific tables in the data store that are not to be used as geospatial tables. |
boolean |
allSameOrder(String[] requestedNames,
SimpleFeatureType ft)
returns true if the requested names list all the attributes in the correct order. |
protected String[] |
attributeNames(SimpleFeatureType featureType,
Filter filter)
Gets the list of attribute names required for both featureType and filter |
protected AttributeDescriptor |
buildAttributeType(ResultSet rs)
Constructs an AttributeDescriptor from a row in a ResultSet. |
protected FIDMapper |
buildFIDMapper(String typeName,
FIDMapperFactory factory)
Builds the appropriate FID mapper given a table name and a FID mapper factory |
protected FIDMapperFactory |
buildFIDMapperFactory(JDBCDataStoreConfig config)
|
protected SimpleFeatureType |
buildSchema(String typeName,
FIDMapper mapper)
Builds the schema for a table in the database. |
protected abstract Connection |
createConnection()
Create a connection for your JDBC1 database |
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
createFeatureReader(SimpleFeatureType schema,
Filter postFilter,
QueryData queryData)
Create a new FeatureReader |
protected JDBCFeatureWriter |
createFeatureWriter(FeatureReader<SimpleFeatureType,SimpleFeature> reader,
QueryData queryData)
|
protected LockingManager |
createLockingManager()
Allows subclass to create LockingManager to support their needs. |
void |
createSchema(SimpleFeatureType featureType)
Create a new featureType. |
protected String |
determineFidColumnName(String typeName)
Provides the default implementation of determining the FID column. |
protected int |
determineSRID(String tableName,
String geometryColumnName)
Provides a hook for subclasses to determine the SRID of a geometry column. |
protected QueryData |
executeQuery(FeatureTypeInfo featureTypeInfo,
String tableName,
String sqlQuery,
Transaction transaction,
boolean forWrite)
See the full version with hints support |
protected QueryData |
executeQuery(FeatureTypeInfo featureTypeInfo,
String tableName,
String sqlQuery,
Transaction transaction,
boolean forWrite,
Hints hints)
Executes the SQL Query. |
protected AttributeIO |
getAttributeIO(AttributeDescriptor type)
Returns the basic AttributeIO that can read and write all of the simple data types |
protected AttributeDescriptor[] |
getAttributeTypes(String typeName,
String[] propertyNames)
Gets the attribute types from from a given type. |
protected int |
getConcurrency(boolean forWrite)
|
Connection |
getConnection(Transaction transaction)
Gets a connection for the provided transaction. |
String |
getDatabaseSchemaName()
Returns the database schema used by this JDBC datastore |
Envelope |
getEnvelope(String typeName)
Retrieve approx bounds of all Features. |
FeatureReader<SimpleFeatureType,SimpleFeature> |
getFeatureReader(Query query,
Transaction trans)
The top level method for getting a FeatureReader. |
FeatureReader<SimpleFeatureType,SimpleFeature> |
getFeatureReader(SimpleFeatureType requestType,
Filter filter,
Transaction transaction)
This is a public entry point to the DataStore. |
FeatureSource<SimpleFeatureType,SimpleFeature> |
getFeatureSource(Name typeName)
Delegates to getFeatureSource(String) with
name.getLocalPart() |
FeatureSource<SimpleFeatureType,SimpleFeature> |
getFeatureSource(String typeName)
Default implementation based on getFeatureReader and getFeatureWriter. |
protected FeatureTypeHandler |
getFeatureTypeHandler(JDBCDataStoreConfig config)
DOCUMENT ME! |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
getFeatureWriter(String typeName,
Filter filter,
Transaction transaction)
Acquire FeatureWriter for modification of contents specifed by filter. |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
getFeatureWriter(String typeName,
Transaction transaction)
Retrieve a FeatureWriter over entire dataset. |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
getFeatureWriterAppend(String typeName,
Transaction transaction)
Retrieve a FeatureWriter for creating new content. |
FIDMapper |
getFIDMapper(String tableName)
|
FIDMapperFactory |
getFIDMapperFactory()
Returns the FIDMapperFactory used for this data store |
protected abstract AttributeIO |
getGeometryAttributeIO(AttributeDescriptor type,
QueryData queryData)
Hook to create the geometry attribute IO for a vendor specific data source. |
ServiceInfo |
getInfo()
Information about this service. |
protected JDBCFeatureReader |
getJDBCFeatureReader(QueryData queryData)
|
LockingManager |
getLockingManager()
Locking manager used for this DataStore. |
List<Name> |
getNames()
Returns the same list of names than getTypeNames() meaning the
returned Names have no namespace set. |
URI |
getNameSpace()
Gets the namespace of the data store. |
protected int |
getResultSetType(boolean forWrite)
|
SimpleFeatureType |
getSchema(Name name)
Delegates to getSchema(String) with name.getLocalPart() |
SimpleFeatureType |
getSchema(String typeName)
Retrieve FeatureType metadata by typeName . |
SQLBuilder |
getSqlBuilder(String typeName)
Hook for subclass to return a different sql builder. |
String |
getSqlNameEscape()
Gets the SQL name escape string. |
Set |
getSupportedHints()
|
int |
getTransactionIsolation()
Obtain the transaction isolation level for connections. |
String[] |
getTypeNames()
Retrieves a list of of the available FeatureTypes. |
FeatureSource<SimpleFeatureType,SimpleFeature> |
getView(Query query)
Access a FeatureSource |
protected String[] |
propertyNames(Query query)
Get propertyNames in a safe manner. |
protected boolean |
requireAutoCommit()
Return true if transaction is handled on client. |
protected void |
setAutoCommit(boolean forWrite,
Connection conn)
This method should be overridden to do nothing by DataStores where setting autoCommit causes funky behaviour (ie. anytime autoCommit is changed, every thing up to that point is committed...this isn't good at this stage) |
void |
setFIDMapper(String featureTypeName,
FIDMapper fidMapper)
Sets the FIDMapper for a specific type name |
void |
setFIDMapperFactory(FIDMapperFactory fmFactory)
Allows to override the default FIDMapperFactory. |
protected void |
setSqlNameEscape(String sqlNameEscape)
Sets the SQL name escape string. |
void |
setTransactionIsolation(int value)
Sets the transaction isolation level for connections. |
void |
updateSchema(Name typeName,
SimpleFeatureType featureType)
Delegates to updateSchema(String, SimpleFeatureType) with
name.getLocalPart() |
void |
updateSchema(String typeName,
SimpleFeatureType featureType)
Used to provide support for changing the DataStore Schema. |
Methods inherited from class Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Methods inherited from interface DataAccess |
---|
dispose |
Field Detail |
---|
protected static final Logger LOGGER
public static final Map TYPE_MAPPINGS
These mappings were taken from http://java.sun.com/j2se/1.3/docs/guide/jdbc/getstart/mapping.html#997737
public FeatureListenerManager listenerManager
protected final JDBCDataStoreConfig config
protected FeatureTypeHandler typeHandler
protected String sqlNameEscape
protected boolean allowWriteOnVolatileFIDs
FIDMapper.isVolatile()
protected int transactionIsolation
Constructor Detail |
---|
public JDBC1DataStore(JDBCDataStoreConfig config) throws IOException
config
-
IOException
Method Detail |
---|
public String getSqlNameEscape()
The value of this string is prefixed and appended to table schema names, table names and column names in an SQL statement to support mixed-case and non-English names.
protected void setSqlNameEscape(String sqlNameEscape)
The value of this string is prefixed and appended to table schema names, table names and column names in an SQL statement to support mixed-case and non-English names.
This value is typically only set once when the DataStore implementation class is constructed.
sqlNameEscape
- the name escape characterprotected FeatureTypeHandler getFeatureTypeHandler(JDBCDataStoreConfig config) throws IOException
config
-
IOException
- DOCUMENT ME!protected FIDMapperFactory buildFIDMapperFactory(JDBCDataStoreConfig config)
public FIDMapper getFIDMapper(String tableName) throws IOException
IOException
protected LockingManager createLockingManager()
public ServiceInfo getInfo()
DataAccess
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).
getInfo
in interface DataAccess<SimpleFeatureType,SimpleFeature>
public String[] getTypeNames() throws IOException
DataStore
This is simply a list of the FeatureType names as aquiring the actual FeatureType schemas may be expensive.
Warning: this list may not be unique - the types may be in separate namespaces.
If you need to worry about such things please consider the use of the Catalog and CatalogEntry interface - many DataStores support this. getTypeNames is really a convience method for a Catalog.iterator() where the name of each entry is returned.
getTypeNames
in interface DataStore
IOException
org.geotools.data.DataStore#getFeatureTypes()
public SimpleFeatureType getSchema(String typeName) throws IOException
DataStore
typeName
.
Retrieves the Schema information as a FeatureType object.
getSchema
in interface DataStore
typeName
- typeName of requested FeatureType
IOException
- If typeName cannot be foundDataStore.getSchema(java.lang.String)
public void createSchema(SimpleFeatureType featureType) throws IOException
Not currently supported - subclass may implement.
createSchema
in interface DataAccess<SimpleFeatureType,SimpleFeature>
featureType
-
IOException
UnsupportedOperationException
- Creating new schemas is not supported.org.geotools.data.DataStore#createSchema(org.geotools.feature.FeatureType)
public void updateSchema(String typeName, SimpleFeatureType featureType) throws IOException
Specifically this is intended to address updating the metadata Coordinate System information.
If we can figure out the Catalog API for metadata we will not have to use such a heavy handed approach.
Subclasses are free to implement various levels of support:
updateSchema
in interface DataStore
IOException
org.geotools.data.DataStore#updateSchema(java.lang.String,
org.geotools.feature.FeatureType)
public FeatureSource<SimpleFeatureType,SimpleFeature> getView(Query query) throws IOException, SchemaException
DataStore
The provided Query does not need to completely cover the existing
schema for Query.getTypeName(). The result will mostly likely only be
a FeatureSource
By using Query we allow support for reprojection, in addition to overriding the CoordinateSystem used by the native FeatureType.
We may wish to limit this method to only support Queries using Filter.EXCLUDE.
Update - GeoServer has an elegatent implementation of this functionality that we could steal. GeoServerFeatureSource, GeoServerFeatureStore and GeoServerFeatureLocking serve as a working prototype.
getView
in interface DataStore
query
- Query.getTypeName() locates FeatureType being viewed
IOException
- If FeatureSourceSchemaException
- If fetureType is not covered by existing schemapublic FeatureSource<SimpleFeatureType,SimpleFeature> getFeatureSource(String typeName) throws IOException
We should be able to optimize this to only get the RowSet once
getFeatureSource
in interface DataStore
IOException
DataStore.getFeatureSource(java.lang.String)
public FeatureReader<SimpleFeatureType,SimpleFeature> getFeatureReader(SimpleFeatureType requestType, Filter filter, Transaction transaction) throws IOException
We have given some though to changing this api to be based on query.
Currently the is is the only way to retype your features to different name spaces.
(non-Javadoc)
IOException
protected String[] attributeNames(SimpleFeatureType featureType, Filter filter) throws IOException
featureType
- The FeatureType to get attribute names for.filter
- The filter which needs attributes to filter.
IOException
- If we can't get the schema.public FeatureReader<SimpleFeatureType,SimpleFeature> getFeatureReader(Query query, Transaction trans) throws IOException
Chris- I've gone with the Query object aswell. It just seems to make more sense. This is pretty well split up across methods. The hooks for DB specific AttributeReaders are createResultSetReader and createGeometryReader.
JG- I have implemented getFeatureReader( FeatureType, Filter, Transasction) ontop of this method, it will Retype as required
getFeatureReader
in interface DataStore
query
- The Query to get a FeatureReadertrans
- The transaction this read operation is being performed in.
IOException
- If an error occurs executing the query.
DataSourceException
protected FeatureReader<SimpleFeatureType,SimpleFeature> createFeatureReader(SimpleFeatureType schema, Filter postFilter, QueryData queryData) throws IOException
The provided schema
describes the attributes in the
queryData ResultSet. This schema should cover the requirements of
filter
.
Retyping to the users requested Schema will not happen in this method.
schema
- postFilter
- Filter for post processing, or null
if not
required.queryData
- Holds a ResultSet for attribute Readers
IOException
protected JDBCFeatureReader getJDBCFeatureReader(QueryData queryData) throws IOException
IOException
protected AttributeIO getAttributeIO(AttributeDescriptor type)
type
- protected abstract AttributeIO getGeometryAttributeIO(AttributeDescriptor type, QueryData queryData) throws IOException
type
- The AttributeDescriptor to read.queryData
- The connection holder
IOException
- DOCUMENT ME!protected QueryData executeQuery(FeatureTypeInfo featureTypeInfo, String tableName, String sqlQuery, Transaction transaction, boolean forWrite) throws IOException
featureTypeInfo
- tableName
- sqlQuery
- transaction
- forWrite
-
IOException
protected QueryData executeQuery(FeatureTypeInfo featureTypeInfo, String tableName, String sqlQuery, Transaction transaction, boolean forWrite, Hints hints) throws IOException
This is private in the expectation that subclasses should not need to change this behaviour.
Jody with a question here - I have stopped this method from closing connection shared by a Transaction. It sill seems like we are leaving connections open by using this method. I have also stopped QueryData from doing the same thing.
Answer from Sean: Resources for successful queries are closed when close is called on the AttributeReaders constructed with the QueryData. We can't close them here since they need to be open to read from the ResultSet.
Jody AttributeReader question: I looked at the code and Attribute Readers do not close with respect to Transactions (they need to as we can issue a Reader against a Transaction. I have changed the JDBCDataStore.close method to force us to keep track of these things.
SG: I've marked this as final since I don't think it shoudl be overriden, but Im not sure
featureTypeInfo
- tableName
- sqlQuery
- The SQL query to execute.transaction
- The Transaction is included here for handling transaction
connections at a later stage. It is not currently used.forWrite
- hints
- the Query
hints
IOException
DataSourceException
- If an error occurs performing the query.protected void setAutoCommit(boolean forWrite, Connection conn) throws SQLException
forWrite
- conn
-
SQLException
protected int getResultSetType(boolean forWrite)
protected int getConcurrency(boolean forWrite)
public SQLBuilder getSqlBuilder(String typeName) throws IOException
Subclasses requiring a ClientTransactionAccessor should override and instantiate an SQLBuilder with one in the constructor.
typeName
- The typename for the sql builder.
IOException
- if anything goes wrong.public Connection getConnection(Transaction transaction) throws IOException
transaction
-
IOException
DataSourceException
- If the connection can not be obtained.public int getTransactionIsolation()
setTransactionIsolation
,
This web pagepublic void setTransactionIsolation(int value)
value
- Connection.TRANSACTION_READ_UNCOMMITTED,
Connection.TRANSACTION_READ_COMMITTED,
Connection.TRANSACTION_REPEATABLE_READ,
Connection.SERIALIZABLE, or Connection.TRANSACTION_NONE
(for use default/do not set)protected boolean requireAutoCommit()
protected abstract Connection createConnection() throws SQLException
SQLException
protected boolean allowTable(String tablename)
tablename
- A table name to check.
protected FIDMapper buildFIDMapper(String typeName, FIDMapperFactory factory) throws IOException
typeName
- factory
-
IOException
protected SimpleFeatureType buildSchema(String typeName, FIDMapper mapper) throws IOException
This works by retrieving the column information for the table from the DatabaseMetaData object. It then iterates over the information for each column, calling buildAttributeType(ResultSet) to construct an AttributeDescriptor for each column. The list of attribute types is then turned into a FeatureType that defines the schema.
It is not intended that this method is overriden. It should provide the required functionality for most sub-classes. To add AttributeDescriptor construction for vendor specific SQL types, such as geometries, override the buildAttributeType(ResultSet) method.
This may become final later. In fact Ill make it private because I don't think It will need to be overriden.
typeName
- The name of the table to construct a feature type for.mapper
- The name of the column holding the fid.
IOException
DataSourceException
- This can occur if there is an SQL error or an error
constructing the FeatureType.buildAttributeType(ResultSet)
protected AttributeDescriptor buildAttributeType(ResultSet rs) throws IOException
The default implementation constructs an AttributeDescriptor using the default JDBC type mappings defined in JDBCDataStore. These type mappings only handle native Java classes and SQL standard column types, so to handle Geometry columns, sub classes should override this to check if a column is a geometry column, if it is a geometry column the appropriate determination of the geometry type can be performed. Otherwise, overriding methods should call super.buildAttributeType.
Note: Overriding methods must never move the current row pointer in the result set.
rs
- The ResultSet containing the result of a
DatabaseMetaData.getColumns call.
IOException
- If an error occurs processing the ResultSet.protected int determineSRID(String tableName, String geometryColumnName) throws IOException
This allows SRIDs to be determined in a Vendor specific way and to be cached by the default implementation. To retreive these srids, get the FeatureTypeInfo object for the table and call getSRID(geometryColumnName). This will allow storage of SRIDs for multiple geometry columns in each table.
If no SRID can be found, subclasses should return -1. The default implementation always returns -1.
tableName
- The name of the table to get the SRID for.geometryColumnName
- The name of the geometry column within the table to get SRID
for.
IOException
protected String determineFidColumnName(String typeName) throws IOException
The default implementation of determining the FID column name is to use the primary key as the FID column. If no primary key is present, null will be returned. Sub classes can override this behaviour to define primary keys for vendor specific cases.
There is an unresolved issue as to what to do when there are multiple primary keys. Maybe a restriction that table much have a single column primary key is appropriate.
This should not be called by subclasses to retreive the FID column name. Instead, subclasses should call getFeatureTypeInfo(String) to get the FeatureTypeInfo for a feature type and get the fidColumn name from the fidColumn name memeber.
typeName
- The name of the table to get a primary key for.
IOException
- This will only occur if there is an error getting a
connection to the Database.public URI getNameSpace()
public String getDatabaseSchemaName()
public FeatureWriter<SimpleFeatureType,SimpleFeature> getFeatureWriter(String typeName, Transaction transaction) throws IOException
Quick notes: This FeatureWriter is often used to add new content, or perform summary calculations over the entire dataset.
Subclass may wish to implement an optimized featureWriter for these operations.
It should provide Feature for next() even when hasNext() is
false
.
Subclasses are responsible for checking with the lockingManger unless they are providing their own locking support.
getFeatureWriter
in interface DataStore
typeName
- transaction
-
IOException
org.geotools.data.DataStore#getFeatureWriter(java.lang.String,
boolean, org.geotools.data.Transaction)
public FeatureWriter<SimpleFeatureType,SimpleFeature> getFeatureWriterAppend(String typeName, Transaction transaction) throws IOException
Subclass may wish to implement an optimized featureWriter for this operation. One based on prepaired statemnts is a possibility, as we do not require a ResultSet.
To allow new content the FeatureWriter should provide Feature for next()
even when hasNext() is false
.
Subclasses are responsible for checking with the lockingManger unless they are providing their own locking support.
getFeatureWriterAppend
in interface DataStore
typeName
- transaction
-
IOException
org.geotools.data.DataStore#getFeatureWriter(java.lang.String,
boolean, org.geotools.data.Transaction)
public FeatureWriter<SimpleFeatureType,SimpleFeature> getFeatureWriter(String typeName, Filter filter, Transaction transaction) throws IOException
Quick notes: This FeatureWriter is often used to remove contents specified by the provided filter, or perform summary calculations.
Subclasses are responsible for checking with the lockingManager unless they are providing their own locking support.
getFeatureWriter
in interface DataStore
typeName
- filter
- transaction
-
IOException
- If typeName could not be located
NullPointerException
- If the provided filter is null
DataSourceException
protected JDBCFeatureWriter createFeatureWriter(FeatureReader<SimpleFeatureType,SimpleFeature> reader, QueryData queryData) throws IOException
IOException
protected String[] propertyNames(Query query) throws IOException
Method will figure out names from the schema for query.getTypeName(), if
query getPropertyNames() is null
, or
query.retrieveAllProperties is true
.
query
-
IOException
protected final AttributeDescriptor[] getAttributeTypes(String typeName, String[] propertyNames) throws IOException, SchemaException
typeName
- The name of the feature type to get the AttributeTypes for.propertyNames
- The list of propertyNames to get AttributeTypes for.
IOException
- If we can't get the schema.
SchemaException
- if query contains a propertyName that is not a part of this
type's schema.public LockingManager getLockingManager()
By default AbstractDataStore makes use of InProcessLockingManager.
getLockingManager
in interface DataStore
null
, if the handling locking
in another fashion.DataStore.getLockingManager()
public void setFIDMapper(String featureTypeName, FIDMapper fidMapper)
featureTypeName
- fidMapper
- public FIDMapperFactory getFIDMapperFactory()
public void setFIDMapperFactory(FIDMapperFactory fmFactory) throws UnsupportedOperationException
Warning: the ovveride may not be supported by all data stores, in this case an exception will be thrown
fmFactory
-
UnsupportedOperationException
- -
if the datastore does not allow the factory overridepublic boolean allSameOrder(String[] requestedNames, SimpleFeatureType ft)
requestedNames
- ft
- public Envelope getEnvelope(String typeName)
This result is suitable for a quick map display, illustrating the data. This value is often stored as metadata in databases such as oraclespatial.
public Set getSupportedHints()
public FeatureSource<SimpleFeatureType,SimpleFeature> getFeatureSource(Name typeName) throws IOException
getFeatureSource(String)
with
name.getLocalPart()
getFeatureSource
in interface DataAccess<SimpleFeatureType,SimpleFeature>
IOException
DataAccess.getFeatureSource(Name)
public List<Name> getNames() throws IOException
getTypeNames()
meaning the
returned Names have no namespace set.
getNames
in interface DataAccess<SimpleFeatureType,SimpleFeature>
IOException
DataAccess.getNames()
public SimpleFeatureType getSchema(Name name) throws IOException
getSchema(String)
with name.getLocalPart()
getSchema
in interface DataAccess<SimpleFeatureType,SimpleFeature>
name
- Type name a the resource from getNames()
IOException
DataAccess.getSchema(Name)
public void updateSchema(Name typeName, SimpleFeatureType featureType) throws IOException
updateSchema(String, SimpleFeatureType)
with
name.getLocalPart()
updateSchema
in interface DataAccess<SimpleFeatureType,SimpleFeature>
IOException
- if the operation failedDataAccess.getFeatureSource(Name)
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |