JDBCDataStore (Geotools modules 18-SNAPSHOT API)

Object
- ContentDataStore
- - 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 Summary

Fields
Modifier and Type	Field and Description
`protected HashMap<Class<? extends FeatureVisitor>,String>`	`aggregateFunctions` Feature visitor to aggregate function name
`protected boolean`	`associations` flag controlling if the datastore is supporting feature and geometry relationships with associations
`protected int`	`batchInsertSize` The number of features to bufferize while inserting in order to do batch inserts.
`protected JDBCCallbackFactory`	`callbackFactory`
`protected HashMap<Class<?>,Integer>`	`classToSqlTypeMappings` java class to sql type mappings;
`protected List<ConnectionLifecycleListener>`	`connectionLifecycleListeners` The listeners that are allowed to handle the connection lifecycle
`protected String`	`databaseSchema` The database schema.
`protected DataSource`	`dataSource` data source
`protected SQLDialect`	`dialect` the dialect of sql
`protected static ReferencedEnvelope`	`EMPTY_ENVELOPE` The envelope returned when bounds is called against a geometryless feature type
`protected boolean`	`exposePrimaryKeyColumns` flag controlling whether primary key columns of a table are exposed via the feature type.
`protected static String`	`FEATURE_ASSOCIATION_TABLE` name of table to use to store feature associations when `associations` is set.
`protected static String`	`FEATURE_RELATIONSHIP_TABLE` name of table to use to store feature relationships (information about associations) when `associations` is set.
`protected int`	`fetchSize` The fetch size for this datastore, defaulting to 1000.
`protected static String`	`GEOMETRY_ASSOCIATION_TABLE` name of table to use to store geometry associations when `associations` is set.
`protected static String`	`GEOMETRY_TABLE` name of table to use to store geometries when `associations` is set.
`static String`	`JDBC_COLUMN_ALIAS` Used to specify the column alias to use when encoding a column in a select
`static String`	`JDBC_NATIVE_SRID` The native SRID associated to a certain descriptor TODO: qualify this key with 'org.geotools.jdbc'
`static String`	`JDBC_NATIVE_TYPENAME` The key for attribute descriptor user data which specifies the original database column data type.
`static String`	`JDBC_PRIMARY_KEY_COLUMN` Boolean marker stating whether an attribute is part of the primary key
`static String`	`JDBC_READ_ONLY` Boolean marker stating whether the feature type is to be considered read only
`static int`	`MAX_IDS_IN_FILTER` Max number of ids to use for the optimized locks checking filter.
`protected static String`	`MULTI_GEOMETRY_TABLE` name of table to use to store multi geometries made up of non-multi geometries when `associations` is set.
`protected PrimaryKeyFinder`	`primaryKeyFinder` Finds the primary key definitions (instantiated here because the finders might keep state)
`protected HashMap<String,Class<?>>`	`sqlTypeNameToClassMappings` sql type name to java class mappings
`protected HashMap<Integer,Class<?>>`	`sqlTypeToClassMappings` sql type to java class mappings
`protected HashMap<Integer,String>`	`sqlTypeToSqlTypeNameOverrides` sql type to sql type name overrides
`protected static Boolean`	`TRACE_ENABLED` When true, record a stack trace documenting who disposed the JDBCDataStore.
`protected Map<String,VirtualTable>`	`virtualTables` Contains the SQL definition of the various virtual tables

Fields inherited from class ContentDataStore
dataStoreFactory, entries, featureFactory, filterFactory, geometryFactory, JOINED_FEATURE_TYPE, lockingManager, LOGGER, namespaceURI, typeFactory, WRITER_ADD, WRITER_COMMIT, WRITER_UPDATE

Constructor Summary

Constructors
Constructor and Description

JDBCDataStore()

Constructors
Constructor and Description
`JDBCDataStore()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addVirtualTable(VirtualTable vtable)` Deprecated. Use createVirtualTable instead
`Transaction`	`buildTransaction(Connection cx)` Builds a transaction object around a user provided connection.
`void`	`closeSafe(Connection cx)` Utility method for closing a connection.
`void`	`closeSafe(ResultSet rs)` Utility method for closing a result set.
`void`	`closeSafe(Statement st)` Utility method for closing a statement.
`protected String`	`createAssociationTableSQL(Connection cx)` Creates the sql for the association table.
`protected Connection`	`createConnection()` Creates a new connection.
`protected ContentState`	`createContentState(ContentEntry entry)` Creates an instanceof `JDBCState`.
`protected ContentFeatureSource`	`createFeatureSource(ContentEntry entry)` Creates a new instance of `JDBCFeatureStore`.
`protected FilterToSQL`	`createFilterToSQL(SimpleFeatureType featureType)` Creates a new instance of a filter to sql encoder.
`protected String`	`createGeometryAssociationTableSQL(Connection cx)` Creates the sql for the geometry association table.
`protected String`	`createGeometryTableSQL(Connection cx)` Creates the sql for the geometry table.
`void`	`createIndex(Index index)` Creates a new database index
`protected String`	`createMultiGeometryTableSQL(Connection cx)` Creates the sql for the multi_geometry table.
`protected PreparedFilterToSQL`	`createPreparedFilterToSQL(SimpleFeatureType featureType)` Creates a new instance of a filter to sql encoder to be used in a prepared statement.
`protected String`	`createRelationshipTableSQL(Connection cx)` Creates the sql for the relationship table.
`void`	`createSchema(SimpleFeatureType featureType)` Creates a table in the underlying database from the specified table.
`protected String`	`createTableSQL(SimpleFeatureType featureType, Connection cx)` Generates a 'CREATE TABLE' sql statement.
`protected List`	`createTypeNames()` Generates the list of type names provided by the database.
`void`	`createVirtualTable(VirtualTable vtable)` Adds a virtual table to the data store.
`protected static List<Object>`	`decodeFID(PrimaryKey key, String FID, boolean strict)` Decodes a fid into its components based on a primary key.
`protected void`	`delete(SimpleFeatureType featureType, Filter filter, Connection cx)` Deletes an existing feature(s) in the database for a particular feature type / table.
`protected void`	`delete(SimpleFeatureType featureType, String fid, Connection cx)` Deletes an existing feature in the database for a particular feature type / fid.
`protected String`	`deleteSQL(SimpleFeatureType featureType, Filter filter)` Generates a 'DELETE FROM' sql statement.
`protected PreparedStatement`	`deleteSQLPS(SimpleFeatureType featureType, Filter filter, Connection cx)` Generates a 'DELETE FROM' prepared statement.
`void`	`dispose()` Disposes of this data store and releases any resource that it is using.
`void`	`dropIndex(String typeName, String indexName)` Creates a new database index
`protected String`	`dropTableSQL(SimpleFeatureType featureType, Connection cx)` Generates a 'DROP TABLE' sql statement.
`VirtualTable`	`dropVirtualTable(String name)` Removes and returns the specified virtual table
`protected void`	`encodeAliasedTableName(String tableName, StringBuffer sql, Hints hints, String alias)` 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
`protected void`	`encodeAttribute(AttributeDescriptor attribute, Query query, StringBuffer sql)` Helper method that adds an attribute to SQL query with a special handling for geometry descriptor.
`protected static String`	`encodeFID(List<Object> keyValues)`
`protected String`	`encodeFID(PrimaryKey pkey, ResultSet rs)` Calls through to: `encodeFID(pkey, rs, 0);`
`protected String`	`encodeFID(PrimaryKey pkey, ResultSet rs, int offset)` Encodes a feature id from a primary key and result set values.
`protected void`	`encodeFunction(String function, AttributeDescriptor att, Query query, StringBuffer sql)`
`protected void`	`encodeGeometryColumn(GeometryDescriptor gatt, StringBuffer sql, Hints hints)` Encoding a geometry column with respect to hints Supported Hints are provided by `SQLDialect.addSupportedHints(Set)`
`protected void`	`encodeGeometryColumn(GeometryDescriptor gatt, String prefix, StringBuffer sql, Hints hints)`
`protected void`	`encodeGroupByAttributes(List<AttributeDescriptor> attributes, Query query, StringBuffer sql)`
`protected void`	`encodeGroupByStatement(List<AttributeDescriptor> attributes, Query query, StringBuffer sql)` Helper method that adds a group by statement to the SQL query.
`protected void`	`encodeTableJoin(SimpleFeatureType featureType, JoinInfo join, Query query, StringBuffer sql)` Helper method to encode the join clause(s) of a query.
`protected void`	`encodeTableName(String tableName, StringBuffer sql, Hints hints)` Helper method to encode table name which checks if a schema is set and prefixes the table name with it.
`protected List<FilterToSQL>`	`encodeWhereJoin(SimpleFeatureType featureType, JoinInfo join, StringBuffer sql)`
`protected void`	`ensureAssociationTablesExist(Connection cx)` Helper method for creating geometry association table if it does not exist.
`protected void`	`ensureAuthorization(SimpleFeatureType featureType, Filter filter, Transaction tx, Connection cx)` Ensures that that the specified transaction has access to features specified by a filter.
`String`	`escapeNamePattern(DatabaseMetaData metaData, String name)` Escapes a name pattern used in e.g.
`protected AttributeDescriptor`	`extractAggregateAttribute(FeatureVisitor visitor, SimpleFeatureType featureType)` Helper method that extract the attribute that will be used by the aggregate function.
`protected List<AttributeDescriptor>`	`extractGroupByAttributes(FeatureVisitor visitor, SimpleFeatureType featureType)` Helper method that extracts a list of group by attributes from a group by visitor.
`protected GroupByVisitor.GroupByRawResult`	`extractValuesFromResultSet(ResultSet resultSet, int numberOfGroupByAttributes)` Helper method that translate the result set to the appropriate group by visitor result format
`protected void`	`finalize()`
`protected String`	`findPrimaryKeyColumnName(SimpleFeatureType featureType)`
`JDBCFeatureSource`	`getAbsoluteFeatureSource(String typeName)`
`Map<Class<? extends FeatureVisitor>,String>`	`getAggregateFunctions()` Returns the supported aggregate functions and the visitors they map to.
`protected Object`	`getAggregateValue(FeatureVisitor visitor, SimpleFeatureType featureType, Query query, Connection cx)` Results the value of an aggregate function over a query.
`int`	`getBatchInsertSize()`
`protected ReferencedEnvelope`	`getBounds(SimpleFeatureType featureType, Query query, Connection cx)` Returns the bounds of the features for a particular feature type / table.
`JDBCCallbackFactory`	`getCallbackFactory()`
`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.
`protected static LinkedHashSet<String>`	`getColumnNames(PrimaryKey key)` Returns the set of the primary key column names.
`protected Class`	`getColumnType(DatabaseMetaData metaData, String databaseSchema2, String tableName, String columnName)` Returns the type of the column by inspecting the metadata, with the collaboration of the dialect
`protected Connection`	`getConnection(JDBCState state)` Gets a database connection for the specified feature store.
`Connection`	`getConnection(Transaction t)` Returns a JDBC Connection to the underlying database for the specified GeoTools `Transaction`.
`List<ConnectionLifecycleListener>`	`getConnectionLifecycleListeners()` Returns a modifiable list of connection lifecycle listeners
`protected int`	`getCount(SimpleFeatureType featureType, Query query, Connection cx)` Returns the count of the features for a particular feature type / table.
`String`	`getDatabaseSchema()` The schema from which this datastore is serving tables from.
`DataSource`	`getDataSource()` The data source the datastore uses to obtain connections to the underlying database.
`protected int`	`getDescriptorDimension(AttributeDescriptor descriptor)` Extracts the eventual native dimension user property from the descriptor, returns -1 if not found
`protected int`	`getDescriptorSRID(AttributeDescriptor descriptor)` Extracts the eventual native SRID user property from the descriptor, returns -1 if not found
`int`	`getFetchSize()` The current fetch size.
`FilterCapabilities`	`getFilterCapabilities()` The filter capabilities which reports which spatial operations the underlying database can handle natively.
`protected int`	`getGeometryDimension(Geometry g, AttributeDescriptor descriptor)` Looks up the geometry dimension by trying a number of heuristics.
`protected int`	`getGeometrySRID(Geometry g, AttributeDescriptor descriptor)` Looks up the geometry srs by trying a number of heuristics.
`Object`	`getGmlObject(GmlObjectId id, Hints hints)` Looks up an object by its gml id.
`List<Index>`	`getIndexes(String typeName)` Lists all indexes associated to the given feature type
`Integer`	`getMapping(Class<?> clazz)` Returns the sql type mapped to the specified java type.
`Class<?>`	`getMapping(int sqlType)` Returns the java type mapped to the specified sql type.
`Class<?>`	`getMapping(String sqlTypeName)` Returns the java type mapped to the specified sql type name.
`protected PrimaryKey`	`getPrimaryKey(ContentEntry entry)` Returns the primary key object for a particular entry, deriving it from the underlying database metadata.
`protected PrimaryKey`	`getPrimaryKey(SimpleFeatureType featureType)` Returns the primary key object for a particular feature type / table, deriving it from the underlying database metadata.
`PrimaryKeyFinder`	`getPrimaryKeyFinder()` Returns the finder used to build `PrimaryKey` representations
`protected String`	`getPropertyName(SimpleFeatureType featureType, PropertyName propertyName)` Helper method for executing a property name against a feature type.
`SQLDialect`	`getSQLDialect()` The dialect the datastore uses to generate sql statements in order to communicate with the underlying database.
`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.
`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.
`Map<Integer,String>`	`getSqlTypeToSqlTypeNameOverrides()` Returns any ovverides which map integer constants for database types (from `Types`) to database type names.
`Map<String,VirtualTable>`	`getVirtualTables()` Returns a live, immutable view of the virtual tables map (from name to definition)
`protected <F extends FilterToSQL> F`	`initializeFilterToSQL(F toSQL, SimpleFeatureType featureType)` Helper method to initialize a filter encoder instance.
`protected void`	`insert(Collection<? extends SimpleFeature> features, SimpleFeatureType featureType, Connection cx)` Inserts a collection of new features into the database for a particular feature type / table.
`protected void`	`insert(SimpleFeature feature, SimpleFeatureType featureType, Connection cx)` Inserts a new feature into the database for a particular feature type / table.
`protected String`	`insertSQL(SimpleFeatureType featureType, SimpleFeature feature, KeysFetcher keysFetcher, Connection cx)` Generates a 'INSERT INFO' sql statement.
`boolean`	`isAssociations()` Flag controlling if the datastore is supporting feature and geometry relationships with associations
`protected boolean`	`isCountVisitor(FeatureVisitor visitor)`
`boolean`	`isExposePrimaryKeyColumns()` Determines if the datastore creates feature types which include those columns / attributes which compose the primary key.
`protected boolean`	`isExposePrimaryKeyColumns(SimpleFeatureType featureType)` Returns the expose primary key columns flag for the specified feature type
`protected boolean`	`isGeneralizationRequired(Hints hints, GeometryDescriptor gatt)` Checks if geometry generalization required and makes sense
`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.
`protected boolean`	`isGeometryReduceRequired(Hints hints, GeometryDescriptor gatt, Hints.Key param)` Checks if reduction required and makes sense
`protected boolean`	`isGroupByVisitor(FeatureVisitor visitor)` Helper method the checks if a feature visitor is a group by visitor,
`protected boolean`	`isSimplificationRequired(Hints hints, GeometryDescriptor gatt)` Checks if geometry simplification required and makes sense
`protected String`	`matchAggregateFunction(FeatureVisitor visitor)` Helper method that will try to match a feature visitor with an aggregate function.
`protected void`	`releaseConnection(Connection cx, JDBCState state)` Releases an existing connection (paying special attention to `Transaction.AUTO_COMMIT`.
`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.
`VirtualTable`	`removeVirtualTable(String name)` Deprecated. Use dropVirtualTable instead
`protected String`	`selectAggregateSQL(String function, AttributeDescriptor att, List<AttributeDescriptor> groupByAttributes, SimpleFeatureType featureType, Query query, LimitingVisitor visitor)`
`protected String`	`selectAggregateSQL(String function, AttributeDescriptor att, SimpleFeatureType featureType, Query query, LimitingVisitor visitor)` Generates a 'SELECT () FROM' statement.
`protected PreparedStatement`	`selectAggregateSQLPS(String function, AttributeDescriptor att, List<AttributeDescriptor> groupByAttributes, SimpleFeatureType featureType, Query query, LimitingVisitor visitor, Connection cx)`
`protected PreparedStatement`	`selectAggregateSQLPS(String function, AttributeDescriptor att, SimpleFeatureType featureType, Query query, LimitingVisitor visitor, Connection cx)` Generates a 'SELECT () FROM' prepared statement.
`protected String`	`selectAssociationSQL(String fid)` Creates the sql for the association table.
`protected PreparedStatement`	`selectAssociationSQLPS(String fid, Connection cx)` Creates the prepared statement for the association table.
`protected String`	`selectBoundsSQL(SimpleFeatureType featureType, Query query)` Generates a 'SELECT' sql statement which selects bounds.
`protected PreparedStatement`	`selectBoundsSQLPS(SimpleFeatureType featureType, Query query, Connection cx)` Generates a 'SELECT' prepared statement which selects bounds.
`protected String`	`selectCountSQL(SimpleFeatureType featureType, Query query, LimitingVisitor visitor)` Generates a 'SELECT count(*) FROM' sql statement.
`protected PreparedStatement`	`selectCountSQLPS(SimpleFeatureType featureType, Query query, LimitingVisitor visitor, Connection cx)` Generates a 'SELECT count(*) FROM' prepared statement.
`protected String`	`selectGeometryAssociationSQL(String fid, String gid, String gname)` Creates the sql for a select from the geometry association table.
`protected PreparedStatement`	`selectGeometryAssociationSQLPS(String fid, String gid, String gname, Connection cx)` Creates the prepared statement for a select from the geometry association table.
`protected String`	`selectGeometrySQL(String gid)` Creates the sql for a select from the geometry table.
`protected PreparedStatement`	`selectGeometrySQLPS(String gid, Connection cx)` Creates the prepared for a select from the geometry table.
`protected String`	`selectJoinSQL(SimpleFeatureType featureType, JoinInfo join, Query query)`
`protected PreparedStatement`	`selectJoinSQLPS(SimpleFeatureType featureType, JoinInfo join, Query query, Connection cx)`
`protected String`	`selectMultiGeometrySQL(String gid)` Creates the sql for a select from the multi geometry table.
`protected PreparedStatement`	`selectMultiGeometrySQLPS(String gid, Connection cx)` Creates the prepared statement for a select from the multi geometry table.
`protected String`	`selectRelationshipSQL(String table, String column)` Creates the sql for the relationship table.
`protected PreparedStatement`	`selectRelationshipSQLPS(String table, String column, Connection cx)` Creates the prepared statement for a query against the relationship table.
`protected String`	`selectSQL(SimpleFeatureType featureType, Query query)` Generates a 'SELECT p1, p2, ...
`protected PreparedStatement`	`selectSQLPS(SimpleFeatureType featureType, Query query, Connection cx)` Generates a 'SELECT p1, p2, ...
`void`	`setAssociations(boolean foreignKeyGeometries)` Sets the flag controlling if the datastore is supporting feature and geometry relationships with associations
`void`	`setBatchInsertSize(int batchInsertSize)` Set the number of features to bufferize while inserting in order to do batch inserts.
`void`	`setCallbackFactory(JDBCCallbackFactory factory)`
`void`	`setDatabaseSchema(String databaseSchema)` Set the database schema for the datastore.
`void`	`setDataSource(DataSource dataSource)` Sets the data source the datastore uses to obtain connections to the underlying database.
`void`	`setExposePrimaryKeyColumns(boolean exposePrimaryKeyColumns)` Sets the flag controlling if the datastore creates feature types which include those columns / attributes which compose the primary key.
`void`	`setFetchSize(int fetchSize)` Changes the fetch size.
`protected void`	`setGmlProperties(Geometry g, String gid, String name, String description)` Helper method for setting the gml:id of a geometry as user data.
`protected void`	`setPreparedFilterValues(PreparedStatement ps, List toSQLs, Connection cx)` Helper method for setting the values of the WHERE class of a prepared statement from a list of PreparedFilterToSQL.
`protected void`	`setPreparedFilterValues(PreparedStatement ps, PreparedFilterToSQL toSQL, int offset, Connection cx)` Helper method for setting the values of the WHERE class of a prepared statement.
`void`	`setPrimaryKeyFinder(PrimaryKeyFinder primaryKeyFinder)` Sets the finder used to build `PrimaryKey` representations
`void`	`setSQLDialect(SQLDialect dialect)` Sets the dialect the datastore uses to generate sql statements in order to communicate with the underlying database.
`protected void`	`update(SimpleFeatureType featureType, AttributeDescriptor[] attributes, Object[] values, Filter filter, Connection cx)` Updates an existing feature(s) in the database for a particular feature type / table.
`protected void`	`update(SimpleFeatureType featureType, List<AttributeDescriptor> attributes, List<Object> values, Filter filter, Connection cx)` Updates an existing feature(s) in the database for a particular feature type / table.
`protected String`	`updateSQL(SimpleFeatureType featureType, AttributeDescriptor[] attributes, Object[] values, Filter filter, Set<String> pkColumnNames)` Generates an 'UPDATE' sql statement.
`protected PreparedStatement`	`updateSQLPS(SimpleFeatureType featureType, AttributeDescriptor[] attributes, Object[] values, Filter filter, Set<String> pkColumnNames, Connection cx)` Generates an 'UPDATE' prepared statement.

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

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_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
- GEOMETRY_TABLE
```
protected static final String GEOMETRY_TABLE
```
  name of table to use to store geometries when associations is set.
  
  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
```
protected 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
- aggregateFunctions
```
protected HashMap<Class<? extends FeatureVisitor>,String> aggregateFunctions
```
  Feature visitor to aggregate function name
- associations
```
protected boolean associations
```
  flag controlling if the datastore is supporting feature and geometry relationships with associations
- fetchSize
```
protected 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
- callbackFactory
```
protected JDBCCallbackFactory callbackFactory
```

Constructor Detail
- JDBCDataStore
```
public JDBCDataStore()
```

Method Detail

setCallbackFactory

public void setCallbackFactory(JDBCCallbackFactory factory)

getCallbackFactory

public JDBCCallbackFactory getCallbackFactory()

getAbsoluteFeatureSource

public JDBCFeatureSource getAbsoluteFeatureSource(String typeName)
                                           throws IOException

Throws:: IOException

addVirtualTable
```
public void addVirtualTable(VirtualTable vtable)
                     throws IOException
```
Deprecated. Use createVirtualTable instead

Adds a virtual table to the data store. If a virtual table with the same name was registered this method will replace it with the new one. * @param vt

Throws:

IOException - If the view definition is not valid

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 this method will replace it with the new one. * @param vt

Throws:

IOException - If the view definition is not valid

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

Returns:

removeVirtualTable
```
public VirtualTable removeVirtualTable(String name)
```
Deprecated. Use dropVirtualTable instead

Removes and returns the specified virtual table

Parameters:

name -

Returns:

dropVirtualTable
```
public VirtualTable dropVirtualTable(String name)
```
Removes and returns the specified virtual table

Parameters:

name -

Returns:

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

Returns:

getPrimaryKeyFinder
```
public PrimaryKeyFinder getPrimaryKeyFinder()
```
Returns the finder used to build PrimaryKey representations

Returns:

setPrimaryKeyFinder
```
public void setPrimaryKeyFinder(PrimaryKeyFinder primaryKeyFinder)
```
Sets the finder used to build PrimaryKey representations

Parameters:

primaryKeyFinder -

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.

Returns:

setFetchSize
```
public void setFetchSize(int fetchSize)
```
Changes the fetch size.

Parameters:

fetchSize -

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.

Parameters:

batchInsertSize -

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.
 







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)








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>
Overrides:
removeSchema in class ContentDataStore
Throws:
IOException - if the operation failed
See Also:
DataAccess.removeSchema(Name)








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.








createFeatureSource
protected ContentFeatureSource createFeatureSource(ContentEntry entry)
                                            throws IOException
Creates a new instance of JDBCFeatureStore.

Specified by:
createFeatureSource in class ContentDataStore
Parameters:
entry - The entry.
Returns:
An new instance of ContentFeatureSource for the entry.
Throws:
IOException
See Also:
ContentDataStore.createFeatureSource(ContentEntry)








createContentState
protected ContentState createContentState(ContentEntry entry)
Creates an instanceof JDBCState.

Overrides:
createContentState in class ContentDataStore
Parameters:
entry - The entry.
Returns:
A new instance of ContentState for the entry.
See Also:
ContentDataStore.createContentState(ContentEntry)








createTypeNames
protected List 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
protected 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

Parameters:
featureType - 
Returns:
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








extractAggregateAttribute
protected AttributeDescriptor extractAggregateAttribute(FeatureVisitor visitor,
                                                        SimpleFeatureType featureType)
Helper method that extract the attribute that will be used by the aggregate function.

Parameters:
visitor - the feature visitor
featureType - the feature type
Returns:
the aggregate attribute or NULL if the visitor don't contains an aggregate attribute








extractGroupByAttributes
protected List<AttributeDescriptor> extractGroupByAttributes(FeatureVisitor visitor,
                                                             SimpleFeatureType featureType)
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
featureType - the feature type
Returns:
the list of the group by attributes or an empty list








extractValuesFromResultSet
protected GroupByVisitor.GroupByRawResult extractValuesFromResultSet(ResultSet resultSet,
                                                                     int numberOfGroupByAttributes)
                                                              throws SQLException
Helper method that translate the result set to the appropriate group by visitor result format

Throws:
SQLException








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 be null, in that case a new connection will
            be returned (as if Transaction.AUTO_COMMIT was provided)
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
protected 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)
attributes - the properties queried, or Query.ALL_NAMES to gather
            all of them
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
sort - sort conditions
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)
attributes - the properties queried, or Query.ALL_NAMES to gather
            all of them
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 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
protected 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








getPropertyName
protected String getPropertyName(SimpleFeatureType featureType,
                                 PropertyName propertyName)
Helper method for executing a property name against a feature type.
 
 This method will fall back on PropertyName.getPropertyName() if
 it does not evaulate against the feature type.
 







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








selectCountSQL
protected String selectCountSQL(SimpleFeatureType featureType,
                                Query query,
                                LimitingVisitor visitor)
                         throws SQLException,
                                IOException
Generates a 'SELECT count(*) FROM' sql statement. In case limit/offset is 
 used, we'll need to apply them on a select *
 as limit/offset usually alters the number of returned rows 
 (and a count returns just one), and then count on the result of that first select


Throws:
SQLException
IOException








selectCountSQLPS
protected PreparedStatement selectCountSQLPS(SimpleFeatureType featureType,
                                             Query query,
                                             LimitingVisitor visitor,
                                             Connection cx)
                                      throws SQLException,
                                             IOException
Generates a 'SELECT count(*) FROM' prepared statement.

Throws:
SQLException
IOException








selectAggregateSQL
protected String selectAggregateSQL(String function,
                                    AttributeDescriptor att,
                                    SimpleFeatureType featureType,
                                    Query query,
                                    LimitingVisitor visitor)
                             throws SQLException,
                                    IOException
Generates a 'SELECT () FROM' statement.

Throws:
SQLException
IOException








selectAggregateSQL
protected String selectAggregateSQL(String function,
                                    AttributeDescriptor att,
                                    List<AttributeDescriptor> groupByAttributes,
                                    SimpleFeatureType featureType,
                                    Query query,
                                    LimitingVisitor visitor)
                             throws SQLException,
                                    IOException

Throws:
SQLException
IOException








selectAggregateSQLPS
protected PreparedStatement selectAggregateSQLPS(String function,
                                                 AttributeDescriptor att,
                                                 SimpleFeatureType featureType,
                                                 Query query,
                                                 LimitingVisitor visitor,
                                                 Connection cx)
                                          throws SQLException,
                                                 IOException
Generates a 'SELECT () FROM' prepared statement.

Throws:
SQLException
IOException








selectAggregateSQLPS
protected PreparedStatement selectAggregateSQLPS(String function,
                                                 AttributeDescriptor att,
                                                 List<AttributeDescriptor> groupByAttributes,
                                                 SimpleFeatureType featureType,
                                                 Query query,
                                                 LimitingVisitor visitor,
                                                 Connection cx)
                                          throws SQLException,
                                                 IOException

Throws:
SQLException
IOException








encodeGroupByAttributes
protected void encodeGroupByAttributes(List<AttributeDescriptor> attributes,
                                       Query query,
                                       StringBuffer sql)







encodeGroupByStatement
protected void encodeGroupByStatement(List<AttributeDescriptor> attributes,
                                      Query query,
                                      StringBuffer sql)
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:
attributes - the group by attributes to be encoded
query - the query information
sql - the sql query buffer








encodeAttribute
protected void encodeAttribute(AttributeDescriptor attribute,
                               Query query,
                               StringBuffer sql)
Helper method that adds an attribute to SQL query with a special handling for geometry descriptor.

Parameters:
attribute - the attribute descriptor to be encoded
query - the query information
sql - the sql query buffer








encodeFunction
protected void encodeFunction(String function,
                              AttributeDescriptor att,
                              Query query,
                              StringBuffer sql)







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:
IOException
SQLException








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

Parameters:
descriptor - 








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

Parameters:
descriptor - 








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
protected 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
protected 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
protected 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
protected 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








encodeWhereJoin
protected List<FilterToSQL> encodeWhereJoin(SimpleFeatureType featureType,
                                            JoinInfo join,
                                            StringBuffer sql)
                                     throws IOException

Throws:
IOException








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.







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








isGeometryReduceRequired
protected boolean isGeometryReduceRequired(Hints hints,
                                           GeometryDescriptor gatt,
                                           Hints.Key param)
Checks if reduction required and makes sense

Parameters:
hints - hints passed in
gatt - Geometry attribute descriptor
param - Hints.GEOMETRY_GENERALIZATION or Hints.GEOMETRY_SIMPLIFICATION
Returns:
true to indicate reducing the geometry, false otherwise








encodeGeometryColumn
protected void encodeGeometryColumn(GeometryDescriptor gatt,
                                    StringBuffer sql,
                                    Hints hints)
Encoding a geometry column with respect to hints
 Supported Hints are provided by SQLDialect.addSupportedHints(Set)

Parameters:
gatt - 
sql - 
hints - , may be null








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:
conn - The externally managed connection








createIndex
public void createIndex(Index index)
                 throws IOException
Creates a new database index

Parameters:
index - 
Throws:
IOException








dropIndex
public void dropIndex(String typeName,
                      String indexName)
               throws IOException
Creates a new database index

Parameters:
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
Returns:
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

Class JDBCDataStore

Dialects

Database Connections

Schemas

Spatial Functions

Field Summary

Fields inherited from class ContentDataStore

Constructor Summary

Method Summary

Methods inherited from class ContentDataStore

Methods inherited from class Object

Field Detail

TRACE_ENABLED

JDBC_NATIVE_SRID

JDBC_READ_ONLY

JDBC_PRIMARY_KEY_COLUMN

JDBC_NATIVE_TYPENAME

JDBC_COLUMN_ALIAS

GEOMETRY_TABLE

MULTI_GEOMETRY_TABLE

GEOMETRY_ASSOCIATION_TABLE

FEATURE_RELATIONSHIP_TABLE

FEATURE_ASSOCIATION_TABLE

EMPTY_ENVELOPE

MAX_IDS_IN_FILTER

dataSource

dialect

databaseSchema

sqlTypeToClassMappings

sqlTypeNameToClassMappings

classToSqlTypeMappings

sqlTypeToSqlTypeNameOverrides

aggregateFunctions

associations

fetchSize

batchInsertSize

exposePrimaryKeyColumns

primaryKeyFinder

virtualTables

connectionLifecycleListeners

callbackFactory

Constructor Detail

JDBCDataStore

Method Detail

setCallbackFactory

getCallbackFactory

getAbsoluteFeatureSource

addVirtualTable

createVirtualTable

getConnectionLifecycleListeners

removeVirtualTable

dropVirtualTable

getVirtualTables

getPrimaryKeyFinder

setPrimaryKeyFinder

getFetchSize

setFetchSize

getBatchInsertSize

setBatchInsertSize

isExposePrimaryKeyColumns

setExposePrimaryKeyColumns

getSQLDialect

setSQLDialect

getDataSource

setDataSource

getDatabaseSchema

setDatabaseSchema

getFilterCapabilities

isAssociations

setAssociations

getSqlTypeToClassMappings

getSqlTypeNameToClassMappings

getClassToSqlTypeMappings

getSqlTypeToSqlTypeNameOverrides

getAggregateFunctions

getMapping

getMapping

getMapping

createSchema

removeSchema