Holger's Java API

## Package com.antelmann.sql

This package contains classes to ease JDBC development and also provides useful SQL-based implementations for com.antelmann.db classes

See:
Description

Interface Summary
ConnectionWrapper.Listener
ForeignKeyMappingInfo: this interface provides additional mapping information that allows to build more sophisticated SQL-supported filter components solely based on the interface.
MappingInfo: provides basic information about the mapping of a class
ObjectRowMapper<T extends DBEntry>: provides methods to convert an object to a RowItem and vice versa to facilitate persistent storage with JDBC for simple objects.
PropertyEntryMapping: provides mapping information for PropertyEntry objects
Reconnectable: Reconnectable instances are objects that require a connection for certain operations and allow to replace it if a reconnect is required.
RelationshipManager: allows to effectively work with relationships stored in a relational database.
SQLColumnInfo: provides some useful information about certain columns in a table.
SQLComboFilterSupported<T>: denotes filters that are supported by `SQLComboFilter`
SQLConstraint: a tagging interface that marks classes in this package that are supported objects to be used with a ConnectionHelper
TaggableMapping: allows to access relevant information for Taggable objects

Class Summary
BaseDocumentMapper<T extends BaseDocument>: a bases for implementing a store for a given BaseDocument class
BaseRowMapper<T extends DBEntry>: serves as a base class for implementations of ObjectRowMapper.
BeanMapper<T extends DBEntry>: a specialized mapper that allows to map columns to property names based on Bean patterns.
CategoryStore<T extends Category<?> & DBEntry>: provides an SQL-based store wrapper to handle categories more easily based on a column that contains the parent-category-id.
ConnectionHelper: The class JDBC provides several useful methods for handling JDBC connections.
ConnectionWrapper: provides a wrapper for a connection that allows to replace the underlying connection
Connector: The Connector class provides some simplified access to several database systems through convenient methods.
ConnectorSettings: allows to specify how to connect to a database in a serializable manner
DBDocument: DBDocument stores/retrieves the content from a stream out of a table column in a relational database.
DBDocument.Header
DBDocumentStore<T extends DBDocument>
DBDocumentStore.Mapper<T extends DBDocument>
DefaultMappingInfo: provides a default implementation for the `MappingInfo` interface, making it easy to allow other objects to delegate the interface methods to an instance of this class.
DetailRowStore<T extends PropertyEntry>: Deprecated. use `PropertyEntryTableStore` instead
DriverWrapper: wraps a given driver (that is potentially loaded from a URLClassLoader) so that it can be loaded from the system class loader.
ForeignKeyMappingInfo.Analyzer
FullTextSearchFilter<T>: used in context with a `BaseRowMapper` to support full text search in tables
GenericPropertyEntryMapper<T extends PropertyEntry>: provides an easy way to map a table to a PropertyEntry class; this implementation makes several (common) assumptions about the mapping.
GenericPropertyEntryStore<T extends PropertyEntry>: automatically maps a PropertyEntry class to a database, where some default assumptions have to be met.
JConnectionLogin: a GUI to establish a database connection.
JDBCBackup: allows to perform a backup/restore operation on a JDBC connection.
JDBCBackup.TableBegin: used to store the table name uniquely recognizable into the backup stream
JDBCBackup.TableEnd: used to mark the end of a table for the backup stream
JDBCInfoPane: displays generally information on a JDBC connection.
JDBCResourceBundle: a ResourceBundle implementation that receives its values directly from a Connection.
JDBCResourceControl: allows to conveniently store language in a jdbc table, where column names correspond to the locale
JDBCRowModel: JDBCRowModel allows to edit tables where the row is updated only after an explicit method call.
JDBCRowStore<T extends DBEntry>: provides JDBC persistence for Objects that have a corresponding ObjectRowMapper.
JDBCTableEditor: used to edit rows of a table; underlying table is updated after row deselected
JDBCTableModel: JDBCTableModel provides a simple way to display/edit a table from a JDBC connection.
LikeCondition: represents a 'like' condition as can be present in a restriction map in methods of a ConnectionHelper for a text column in a database.
MappedEntryMapper<T extends DBEntry>: a special mapper that completely automates the mapping with specially annotated `DBEntry` classes via reflection.
MSAccessHelper: provides added functionality for Microsoft Access databases
Mysqldump: implements a wrapper around the 'mysqldump' command for ease of use when embedding mysqldump into a Java application
MySQLHelper: provides added functionality for MySQL database
MySQLLog: a custom way to trace a MySQL flexibly over this' frameworks logging mechanism.
MySqlQueryToViewMapper<T extends DBEntry>: enables the automated use of views with MySQL for better performance
NotCondition: negates the given value for generating a where clause; the value may be an Object array or a LikeCondition or any value.
PreparedStatementEntryFilter<T>: a special filter that directly works off a PreparedStatement; only suitable for pre-filtering from the database, unless an internalFilter is set in addition.
PropertyEntryHeaderStore<T extends EntryHeader<?>>: useful for mapping `EntryHeader` objects transparently to support the `PropertyEntry` interface on the header store (for filtering purposes)
PropertyEntryTableStore<T extends PropertyEntry>: a specialized store that provides help for dealing with PropertyEntry objects, assuming that the properties are to be stored in a separate detail table.
PropertyMapper<T extends DBEntry>: allows to easily map only remaining columns that are not mapped otherwise to properties - if applicable and desirable.
RelationshipStore<T extends DefaultEntryRelationship>: provides an SQL-based store for relationships.
RelationshipStore.Mapper<T extends DefaultEntryRelationship>
ResultSetMetaDataTableModel: ResultSetMetaDataTableModel provides a simple way to display the meta data of a ResultSet.
ResultSetTableModel: ResultSetTableModel provides a convenient way to display (or otherwise use) a query result in table format.
RowItem: represents a row in a sql database table and provides convenient access to its properties.
RowItemTableModel: the implementation requires that the columns are properly set on all RowItem objects used within the model.
SerializedEntrySQLMapper<T extends DBEntry>: implements a simple mapper that serializes the entire object and stores it as a stream
SortedGroupableSQLStore<T extends DBEntry & SortedGroupable<G>,G extends Keyword>: a special store that supports SortedGroupable DBEntry instances
SQLColumnInfo.UpdateFilter
SQLColumnInfoStore<T extends DBEntry>: an special store providing an implementation for `SQLColumnInfo` based on a store that provides `MappingInfo`
SQLComboFilter<T>: allows to flexibly combine multiple different filter that all can be effectively applied to a `BaseRowMapper`.
SQLDatabase: implements a database using a SQLTransaction instance based on a JDBC connection.
SQLDirectQueryEntryFilter<T>: a special filter that directly works off a SQL query String; only suitable for pre-filtering from the database, unless an internalFilter is set in addition.
SQLEntryClassMapper: allows to automatically map entry class objects to their respective table names in a database Note: only use this as a `DBConfigListener` if the mapper is associated to a single database, since the complete mapping will be replaced when store changes occur.
SQLFactoryDatabase: provides a specialized sql database which only opens the connection upon transaction begin and then closes it on each commit/abort (and therefore uses a factory).
SQLFetchSizeFilter<T>: allows to specify the intended fetch size to be used for the query when executing a fetch on a store
SQLMapFilter<T>: a special filter that can be used to easily pre-filter Resources via restrictions used in a ConnectionHelper (to fetch them from a DBClassStore).
SQLNumberGenerator: this class is a helper class that provides new IDs or document/product numbers as counters based on flexible intervals.
SQLQueryClause: a special constraint that is taken literally, meaning the string given in the constructor is the exact string used in the final SQL.
SQLServerHelper: provides added functionality for Microsoft SQL Server databases
SQLStubFilter: a special filter that can be used to easily pre-filter Stubs via restrictions used in a ConnectionHelper (to fetch them from a DBClassStore).
SQLTransaction: implements a DBTransaction based on JDBC access.
SQLValueRetriever: allows to specify a serializable retriever for obtaining a value from a database.
SubSelectCondition: allows to specify a sub-query with optional parameters and an operator as a condition for a larger SQL-query-statement.
TableComparator: allows to compare the content of two tables
TableListResourceBundle: a ResourceBundle that initially obtains its content from a JDBC source and caches it as a ListResourceBundle
TaggableHeaderStore<T extends EntryHeader<?>>: useful for mapping `EntryHeader` objects transparently to support the `TaggableMapping` interface on the header store (for filtering purposes)
TaggableMappingImpl: a default implementation that allows to easily adopt a mapping based on JDBC information
TaggablePropertyEntrySQLStore<T extends PropertyEntry & Taggable<G>,G extends Keyword>: a convenient standard implementation of a DBClassStore combining `TaggableMapping` and `PropertyEntryMapping`.
TaggableSQLStore<T extends Taggable<G> & DBEntry,G extends Keyword>: provides a store that can wrap any given store to provide persistence for its grouping capacity based on `Keyword` objects.
TopicMapFilter<T>: a special filter that works very similar to an `SQLMapFilter`, but one instance can be applied to different stores with different mappings - based on the topics.
UnionSqlStore<T extends DBEntry>: implements a read-only store that is based on a union-sql-query derived from the common columns of a number of given stores.
UserImplMapper<T extends UserImpl>: provides a base mapper implementation for storing a User.
UserImplStore<T extends UserImpl>: provides a user store implementation that implements UserLoginStore, so that the database can be queried based on that interface.
WrappedDBClassStoreMapping<T extends DBEntry>: eases the wrapping of stores that need to override certain mapping infos
WrappedObjectRowMapper<T extends DBEntry>: eases the task of wrapping a given mapper and overriding only certain aspects of its behavior.

Enum Summary
BaseDocumentMapper.Column
Connector.DBType: supported database types transparently supported by the Connector class
DBDocumentStore.DBColumn
PropertyEntryMapping.DetailKey: provides topics for `MappingInfo.getMappingForTopic(Object)` that correspond to the additional mapping information given in the constructor
RelationshipManager.Column: provides the topics for the mapping of the store
SQLFunction
SubSelectCondition.Operator

Annotation Types Summary
MappedColumn: The concept of a MappedColumn is very similar to that of a javax.persistence.Column, but since applications in the need of this concept may not want to compile with J2EE, this Annotation is used instead for `MappedEntry` instances.
MappedEntry: used for `DBEntry` classes that can be automatically mapped using annotations.

## Package com.antelmann.sql Description

This package contains classes to ease JDBC development and also provides useful SQL-based implementations for com.antelmann.db classes

(c) Holger Antelmann since 2001- all rights reserved (contact: info@antelmann.com)
see www.antelmann.com/developer for further details and available downloads