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