Holger's Java API

## Uses of Class
com.antelmann.db.DatabaseException

Packages that use DatabaseException
com.antelmann.calendar: This package contains classes for implementing calendar and time related solutions.
com.antelmann.crm: Provides interfaces and classes for implementing applications dealing with Customer Relationship Management (CRM).
com.antelmann.db: This package contains generally useful classes for generic database management.
com.antelmann.genealogy.db: This package provides implementations that manage the persistence for the genealogy package.
com.antelmann.image: This package contains classes for more easily dealing with images.
com.antelmann.io: This package contains classes that are concerned with input/output operations.
com.antelmann.math: This package contains classes to ease calculations.
com.antelmann.net.mail: The classes in this package are designed to ease the handling of emails.
com.antelmann.opengeodb: This package contains classes easing to deal with geological data as provided by http://opengeodb.org/.
com.antelmann.servlet: This package contains classes to help with the implementation of servlets.
com.antelmann.sql: This package contains classes to ease JDBC development and also provides useful SQL-based implementations for com.antelmann.db classes
com.antelmann.util: This package contains generally useful classes that are used throughout the other packages in this framework.
com.antelmann.util.gui: This package contains utility classes for GUI related implementations.

Uses of DatabaseException in com.antelmann.calendar

Methods in com.antelmann.calendar that throw DatabaseException
`void` `SQLCalendarDB.close()`
`void` `CalendarDB.close()`
`boolean` `SQLCalendarDB.containsEntry(CalendarEntry entry)`
`boolean` `CalendarDB.containsEntry(CalendarEntry entry)` entry is there if the id corresponds to an entry in the database; the contained data may be different
`boolean` `SQLCalendarDB.deleteEntry(CalendarEntry entry)` deletes the given entry from the database
`boolean` `FileCalendarDB.deleteEntry(CalendarEntry entry)`
`boolean` `CalendarDB.deleteEntry(CalendarEntry entry)` the corresponding entry in regards to the id will be deleted
`Collection<Alert>` `SQLCalendarDB.getActiveAlerts()`
`Collection<Alert>` `FileCalendarDB.getActiveAlerts()`
`Collection<Alert>` `CalendarDB.getActiveAlerts()` returns all active non-acknowledged alerts
`Collection<Alert>` `SQLCalendarDB.getAlerts(Filter<Alert> filter)`
`Collection<Alert>` `FileCalendarDB.getAlerts(Filter<Alert> filter)`
`Collection<Alert>` `CalendarDB.getAlerts(Filter<Alert> filter)`
`Collection<CalendarEntry>` `SQLCalendarDB.getEntries(Filter<CalendarEntry> filter)`
`Collection<CalendarEntry>` `FileCalendarDB.getEntries(Filter<CalendarEntry> filter)`
`Collection<CalendarEntry>` `CalendarDB.getEntries(Filter<CalendarEntry> filter)`
`void` `SQLCalendarDB.insertAlert(Alert alert)`
`void` `FileCalendarDB.insertAlert(Alert alert)`
`void` `CalendarDB.insertAlert(Alert alert)`
`CalendarEntry` `SQLCalendarDB.insertEntry(CalendarEntry entry)`
`CalendarEntry` `FileCalendarDB.insertEntry(CalendarEntry entry)`
`CalendarEntry` `CalendarDB.insertEntry(CalendarEntry entry)` the id of the given entry is ignored; the returned entry will reflect the actual database object
`void` `SQLCalendarDB.updateAlert(Alert alert)`
`void` `FileCalendarDB.updateAlert(Alert alert)`
`void` `CalendarDB.updateAlert(Alert alert)`
`void` `SQLCalendarDB.updateEntry(CalendarEntry entry)`
`void` `CalendarDB.updateEntry(CalendarEntry entry)`

Uses of DatabaseException in com.antelmann.crm

Methods in com.antelmann.crm that throw DatabaseException
`R` `RoleManager.getRole(DBReference baseEntry)` returns the first role found of the specified type or `null`
`Collection<R>` `RoleManager.getRoles(DBReference baseEntry)` returns a collection of roles for the given base entry or an empty collection
`boolean` `RoleManager.hasRoles(DBReference baseEntry)` determines whether there are roles of type R for the given base entry

Constructors in com.antelmann.crm that throw DatabaseException
`FriendsEntryStore(Database<Connection> db, String table, String idColumn, String fromColumn, String toColumn, String commentColumn, IDFactory idFactory, Class<T> type, Class<? extends DBEntry> entriesWhoAreFriendsClass)`

Uses of DatabaseException in com.antelmann.db

Subclasses of DatabaseException in com.antelmann.db
`class` `ConnectionException` ConnectionException signals access problems with the database.
`class` `DBAccessDeniedWarning` thrown to indicate that access to a database was not allowed due to applicable restrictions
`class` `DBVetoException` thrown to indicate that a listener disagreed with an update of the database
`class` `IntegrityWarning`
`class` `NotApplicableDataWarning` used to indicate a 'minor' problem with the data that is to be displayed as a warning rather than an exception
`class` `TransactionException` thrown to indicate that the caller doesn't hold the lock on an active DBTransaction while trying to access Resources of the associated Database.
`class` `WrongDataException` WrongDataException signals a consistency problem with the data submitted to the database.

Methods in com.antelmann.db that return types with arguments of type DatabaseException
`Processor<T,? extends DatabaseException>` `WrappedDBClassStore.getFetchProcessor()`
`Handler<T,? extends DatabaseException>` `WrappedDBClassStore.getPreStoreHandler()`
`Handler<T,? extends DatabaseException>` `WrappedDBClassStore.getStoreHandler()`
`Processor<Stub<T>,? extends DatabaseException>` `WrappedDBClassStore.getStubProcessor()`

Method parameters in com.antelmann.db with type arguments of type DatabaseException
`void` `WrappedDBClassStore.add(Processor<T,? extends DatabaseException> p)`
`boolean` `WrappedDBClassStore.remove(Processor<T,? extends DatabaseException> p)`
`void` `WrappedDBClassStore.setFetchProcessor(Processor<T,? extends DatabaseException> fetchProcessor)`
`void` `WrappedDBClassStore.setPreStoreHandler(Handler<T,? extends DatabaseException> preStoreHandler)`
`void` `WrappedDBClassStore.setStoreHandler(Handler<T,? extends DatabaseException> storeHandler)`
`void` `WrappedDBClassStore.setStubProcessor(Processor<Stub<T>,? extends DatabaseException> stubProcessor)`

`protected

`<X> Filter<X>`

`

`WrappedDBClassStore.wrapFilterForProcessing(Filter<? super X> filter, Processor<X,? extends DatabaseException> p)`
This method is only used if `WrappedDBClassStore.setProcessBeforeFiltering(boolean)` is set to true.

Methods in com.antelmann.db that throw DatabaseException
`void` `DBTransaction.abort()` aborts this transaction; requires ownership of this instance.
`void` `AbstractDBTransaction.abort()`
`void` `DBAccessController.checkAccess(DBClassStore<?> store, DBClassStore.DBMethod method, Object parameter)` controls access to the database via the `DBClassStore` interface; information on the state of the database (like its current user) can be accessed through the given DBClassStore.
`void` `DBTransaction.commit()` commits all data within the transaction scope to the underlying database; requires ownership of this instance.
`void` `AbstractDBTransaction.commit()`

`static

`<T> T`

`

`DBUtils.commitCall(Callable<T> call, DBTransaction tx)`
commits the given task synchronized to the transaction and aborts the transaction in case of an exception

`static void` `DBUtils.commitEntries(Database<?> db, Iterator<? extends DBEntry> it)`

`static

`<T extends DBEntry> T`

`

`DBUtils.commitEntry(Database<?> db, T entry)`
commits the given entry to the database and returns the given entry

`static

`<T extends DBEntry> T`

`

`DBUtils.commitEntry(DBClassStore<T> store, T entry)`
the store is used to update/insert the entry and the transaction is committed.

`static void` `DBUtils.commitTask(Task<?> task, DBTransaction tx)` commits the given task synchronized to the transaction and aborts the transaction in case of an exception
`boolean` `AbstractDatabase.contains(DBReference ref)`

`

`<T extends DBEntry> boolean`

`

`AbstractDatabase.contains(T entry)`

`boolean` `WrappedDBClassStore.containsID(Object id)`
`boolean` `ReadOnlyCacheStore.containsID(Object id)`
`boolean` `DBClassStoreCache.containsID(Object id)`
`boolean` `DBClassStore.containsID(Object id)` determines whether the given ID is present in this store.
`boolean` `CollectionClassStore.containsID(Object id)`
`boolean` `ArchiveDBClassStore.containsID(Object id)`
`boolean` `AbstractDBClassStore.containsID(Object id)`

`

`<T extends DBEntry> int`

`

`AbstractDatabase.count(Class<T> c, Filter<? super T> filter)`

`

`<T extends DBEntry> int`

`

`AbstractDatabase.countStubs(Class<T> c, Filter<Stub<?>> filter)`

`static TableModel` `DBUtils.createMappingInfoModel(Database<?> db)`
`static TableModel` `DBUtils.createMappingInfoModel(Database<?> db, Monitor mon)`

`static

`<T extends DBEntry> int`

`

`DBUtils.delete(Database<?> db, Iterable<? extends DBReference> list)`
deletes the given entries from the database

`static

`<T extends DBEntry> int`

`

`DBUtils.delete(DBClassStore<T> store, Iterable<T> entries)`
deletes the given entries from the database

`boolean` `AbstractDatabase.delete(DBReference ref)`
`boolean` `AbstractDatabase.delete(Stub<?> stub)`

`

`<T extends DBEntry> boolean`

`

`AbstractDatabase.delete(T entry)`

`int` `WrappedDBClassStore.deleteEntries(Filter<? super T> filter)`
`int` `ReadOnlyStore.deleteEntries(Filter<? super T> filter)`
`int` `ReadOnlyCacheStore.deleteEntries(Filter<? super T> filter)`
`int` `DBClassStoreCache.deleteEntries(Filter<? super T> filter)`
`int` `DBClassStore.deleteEntries(Filter<? super T> filter)` deletes all DBEntry objects that match the given filter; if the filter is null, all resources are deleted.
`int` `CollectionClassStore.deleteEntries(Filter<? super T> filter)`
`int` `ArchiveDBClassStore.deleteEntries(Filter<? super T> filter)`
`int` `AbstractDBClassStore.deleteEntries(Filter<? super T> filter)`
`protected int` `WrappedDBClassStore.deleteEntriesIndividually(Filter<? super T> filter)` deletes all applicable entries by instantiating them and then call `WrappedDBClassStore.deleteEntry(Object)` on each entries.
`boolean` `WrappedDBClassStore.deleteEntry(Object id)`
`boolean` `ReadOnlyStore.deleteEntry(Object id)`
`boolean` `ReadOnlyCacheStore.deleteEntry(Object id)`
`boolean` `EnumDBStore.deleteEntry(Object id)`
`boolean` `DBClassStoreCache.deleteEntry(Object id)`
`boolean` `DBClassStore.deleteEntry(Object id)` removes the entry with the given ID from this store in the database.
`boolean` `CollectionClassStore.deleteEntry(Object id)`
`boolean` `ArchiveDBClassStore.deleteEntry(Object id)`

`static

`<T extends DBEntry> int`

`

`DBUtils.deleteIndividually(DBClassStore<T> store, Filter<? super T> filter)`
deletes all entries that pass the given filter individually

`DBEntry` `DefaultDBReference.dereference(Database<?> db)`
`protected abstract void` `AbstractDBTransaction.doAbort()`
`protected abstract void` `AbstractDBTransaction.doCommit()`
`void` `Stub.ensureReferenceString(Database<?> db)`
`void` `DefaultDBReference.ensureReferenceString(Database<?> db)`
`static DBReference` `DBUtils.ensureReferenceString(Database<?> db, DBReference ref)`
`void` `Stub.ensureReferenceString(DBClassStore<T> store)`
`static void` `DefaultDBReference.ensureReferenceString(DBReference ref, Database<?> db)`
`static boolean` `DBUtils.exists(Database<?> db, DBReference ref)` determines whether there is a relevant store that contains the relevant id for the given reference in the given database
`DBEnumeration<T>` `WrappedDBClassStore.fetch(Filter<? super T> filter)`
`DBEnumeration<T>` `ReadOnlyCacheStore.fetch(Filter<? super T> filter)`
`DBEnumeration<T>` `EnumDBStore.fetch(Filter<? super T> filter)`
`DBEnumeration<T>` `DBClassStoreCache.fetch(Filter<? super T> filter)` adds support for `DBClassStoreCache.PrefetchedFilter`
`DBEnumeration<T>` `DBClassStore.fetch(Filter<? super T> filter)` allows to retrieve the entries of this storage via iteration.
`DBEnumeration<T>` `CollectionClassStore.fetch(Filter<? super T> filter)`
`DBEnumeration<T>` `ArchiveDBClassStore.fetch(Filter<? super T> filter)`
`DBEnumeration<Stub<T>>` `WrappedDBClassStore.fetchStubs(Filter<? super Stub<?>> filter)`
`DBEnumeration<Stub<T>>` `ReadOnlyCacheStore.fetchStubs(Filter<? super Stub<?>> filter)`
`DBEnumeration<Stub<T>>` `DBClassStore.fetchStubs(Filter<? super Stub<?>> filter)` allows to access objects from this store w/o having to instantiate the entire original objects, but instead use Stubs to be able to display the list properly for selection.
`DBEnumeration<Stub<T>>` `CollectionClassStore.fetchStubs(Filter<? super Stub<?>> filter)` the display value of the returned Stub is based on the toString() method of the DBEntry instance
`DBEnumeration<Stub<T>>` `ArchiveDBClassStore.fetchStubs(Filter<? super Stub<?>> filter)`
`DBEnumeration<Stub<T>>` `AbstractDBClassStore.fetchStubs(Filter<? super Stub<?>> filter)`
`static Set<Class<? extends DBEntry>>` `DBUtils.findStoresWithID(Database<?> db, Object id)`
`void` `TransactionListener.finishTransaction(DBTransaction transaction)` called before the transaction commits (and before `TransactionListener.prepareToCommit(DBTransaction)`), so that the commit at the database level can be prevented by throwing a DatabaseException here.
`void` `TransactionListener.Adapter.finishTransaction(DBTransaction transaction)`
`void` `LoggerTransactionListener.finishTransaction(DBTransaction transaction)`
`void` `DBTransactionStoreAdapter.finishTransaction(DBTransaction transaction)`
`void` `DBClassStoreCache.finishTransaction(DBTransaction transaction)`
`boolean` `LockManager.forceUnlock(DBReference ref, long lockTime)` if you don't have the token, you may first obtain the LockInfo and then use its time to release the given lock
`int` `LockManager.forceUnlockForAll(long anyLockAquiredBeforeThisTime)`
`Object` `WrappedDBClassStore.generateNewID()`
`Object` `ReadOnlyStore.generateNewID()`
`Object` `ReadOnlyCacheStore.generateNewID()`
`Object` `EnumDBStore.generateNewID()`
`Object` `DBClassStore.generateNewID()` this method is to generate unique new IDs for the DBEntry at hand - if the application has no other specific way of providing new IDs for this implementation.
`Object` `CollectionClassStore.generateNewID()`
`Object` `TransactionalNumberGenerator.generateNewID(Class<? extends DBEntry> entryClass)` calls `TransactionalNumberGenerator.getRelevantValue()`
`Object` `SessionIdGenerator.generateNewID(Class<? extends DBEntry> entryClass)` this implementation doesn't do anything but returning generateNewID(), thus disregarding the given parameter
`Object` `IDFactory.generateNewID(Class<? extends DBEntry> entryClass)` generates and returns an Object suitable to be used as a new ID for an instance of the given DBEntry class.
`protected abstract String` `SessionIdGenerator.generateSessionPrefix()` this method is to access the database to generate a new session prefix on every call and also store it into the database, so that it is guaranteed that no other call ever re-uses this prefix again.
`protected String` `SessionIdGenerator.generateSQLSessionPrefix(Connection con, String table, String idColumn, String sessionKey, String valueColumn, String separator)`
`static DBEntry` `DBUtils.get(Database<?> db, DBReference ref)` determines whether there is a relevant store that contains the relevant id for the given reference in the given database.
`User[]` `UserLoginStore.getActiveUsers()` returns a generated array of currently active users (never null).
`Iterable<Object>` `CategoryManager.getAllSubCategoryIDs(DBReference categoryRef)`

`

`<T extends DBEntry> T`

`

`AbstractDatabase.getEntry(Class<T> c, Object id)`
a shortcut w/o having to go through the DBClassStore

`DBEntry` `AbstractDatabase.getEntry(DBReference ref)` This method will begin and abort a transaction if none is active at the time.
`T` `WrappedDBClassStore.getEntry(Object id)`
`T` `ReadOnlyCacheStore.getEntry(Object id)`
`T` `DBClassStoreCache.getEntry(Object id)`
`T` `DBClassStore.getEntry(Object id)` returns the DBEntry based on its ID.
`T` `CollectionClassStore.getEntry(Object id)`
`T` `ArchiveDBClassStore.getEntry(Object id)`
`T` `AbstractDBClassStore.getEntry(Object id)`

`

`<T extends DBEntry> T`

`

`AbstractDatabase.getEntry(Stub<T> stub)`
This method will begin and abort a transaction if none is active at the time.

`

`<T extends DBEntry> T`

`

`AbstractDatabase.getFirstEntry(Class<T> type, Filter<? super T> filter)`

`static

`<T extends DBEntry> T`

`

`DBUtils.getFirstEntry(DBClassStore<T> store, Filter<? super T> filter)`

`

`<T extends DBEntry> Stub<T>`

`

`AbstractDatabase.getFirstStub(Class<T> type, Filter<Stub<?>> filter)`

`static

`<T extends DBEntry> Stub<T>`

`

`DBUtils.getFirstStub(DBClassStore<T> store, Filter<? super Stub<?>> filter)`

`LockInfo` `LockManager.getLockInfo(DBReference ref)`
`T` `Stub.getOriginalInstance(Database<?> db)` retrieves and returns the original object for this stub
`T` `Stub.getOriginalInstance(DBClassStore<T> store)` retrieves and returns the original object for this stub

`

`<T extends DBEntry> T`

`

`AbstractDatabase.getRandomEntry(Class<T> type)`

`

`<T extends DBEntry> T`

`

`AbstractDatabase.getRandomEntry(Class<T> type, Filter<? super T> filter)`

`static

`<T extends DBEntry> T`

`

`DBUtils.getRandomEntry(DBClassStore<T> store, Filter<? super T> filter)`

`

`<T extends DBEntry> Stub<T>`

`

`AbstractDatabase.getRandomStub(Class<T> type)`

`static

`<T extends DBEntry> Stub<T>`

`

`DBUtils.getRandomStub(DBClassStore<T> store)`

`T` `EntryHeader.getReferenceEntry(Database<?> db)` retrieves and returns the original object for this EntryHeader
`Long` `TransactionalNumberGenerator.getRelevantValue()` calls `TransactionalNumberGenerator.generateNewCount()` in a transactionally synchronized context

`

`<T extends DBEntry> Stub<T>`

`

`AbstractDatabase.getStub(Class<T> c, Object id)`
a shortcut w/o having to go through the DBClassStore

`Stub<? extends DBEntry>` `AbstractDatabase.getStub(DBReference ref)` This method will begin and abort a transaction if none is active at the time.
`Stub<T>` `WrappedDBClassStore.getStub(Object id)`
`Stub<T>` `ReadOnlyCacheStore.getStub(Object id)`
`Stub<T>` `DBClassStoreCache.getStub(Object id)`
`Stub<T>` `DBClassStore.getStub(Object id)` returns a Stub representing the resource for the given ID or null.
`Stub<T>` `CollectionClassStore.getStub(Object id)`
`Stub<T>` `ArchiveDBClassStore.getStub(Object id)`
`Stub<T>` `AbstractDBClassStore.getStub(Object id)`
`List<? extends Category<?>>` `CategoryManager.getSubCategories(DBReference categoryRef)`
`List<? extends Category<?>>` `CategoryManager.getTopCategories()`
`User` `UserLoginStore.getUserForName(String name)` returns the User associated with the given name or null if no such user exists
`User` `DefaultUserLoginStore.getUserForName(String name)`
`Iterable<String>` `UserLoginStore.getUserNames()` returns a list of valid user names (never null)

`static

`<T extends DBEntry> void`

`

`DBUtils.handle(DBClassStore<T> store, Handler<? super T,?> handler, Filter<? super T> filter, Monitor monitor, boolean useCommitNotAbort)`

`void` `SessionIdGenerator.initNewSession()` this method must be called at least once after instanciation to init a new session for providing unique IDs.
`void` `WrappedDBClassStore.insert(T entry)`
`void` `ReadOnlyStore.insert(T entry)`
`void` `ReadOnlyCacheStore.insert(T entry)`
`void` `EnumDBStore.insert(T entry)`
`void` `DBClassStoreCache.insert(T entry)`
`void` `DBClassStore.insert(T entry)` it is suggested to create the entry with an ID obtained through `generateNewID()` before passing it into this method.
`void` `CollectionClassStore.insert(T entry)`
`Object` `WrappedDBClassStore.insertAsNew(T entry)`
`Object` `ReadOnlyStore.insertAsNew(T entry)`
`Object` `ReadOnlyCacheStore.insertAsNew(T entry)`
`Object` `EnumDBStore.insertAsNew(T entry)`
`Object` `DBClassStore.insertAsNew(T entry)` inserts the given entry using an ID generated by `generateNewID` while ignoring the ID of the given entry.
`Object` `CollectionClassStore.insertAsNew(T entry)` always throws UnsupportedOperationException

`static

`<T extends DBEntry> T`

`

`DBUtils.insertEntry(DBClassStore<T> store, T entry)`
the store is used to insert the entry and the transaction is committed.

`boolean` `DefaultEntryRelationship.isBroken(Database<?> db)` a relationship is NOT broken only if the following applies for both, the from-reference and the to-reference: there is a store in the database for the specified type there exists an entry with the id of the reference in the store
`boolean` `CategoryManager.isLeaf(DBReference categoryRef)`
`boolean` `LockManager.isLocked(DBReference ref)`
`boolean` `LockManager.isLockedWithToken(DBReference ref, String token)`
`boolean` `CategoryManager.isUsed(DBReference categoryRef)`

`static

`<T extends DBEntry> Iterable<T>`

`

`DBUtils.iterate(DBClassStore<T> store, Filter<? super T> filter)`

`

`<T extends DBEntry> ArrayList<T>`

`

`AbstractDatabase.listEntries(Class<T> c, Filter<? super T> filter)`
This method will begin and abort a transaction if none is active at the time.

`

`<T extends DBEntry> ArrayList<T>`

`

`AbstractDatabase.listEntries(Class<T> type, Filter<? super T> filter, int maxEntries)`

`static

`<T extends DBEntry> ArrayList<T>`

`

`DBUtils.listEntries(DBClassStore<T> store, Filter<? super T> filter)`

`static

`<T extends DBEntry> ArrayList<T>`

`

`DBUtils.listEntries(DBClassStore<T> store, Filter<? super T> filter, int maxEntries)`

`

`<T extends DBEntry> ArrayList<Stub<T>>`

`

`AbstractDatabase.listStubs(Class<T> c, Filter<? super Stub<?>> filter)`
This method will begin and abort a transaction if none is active at the time.

`static

`<T extends DBEntry> ArrayList<Stub<T>>`

`

`DBUtils.listStubs(DBClassStore<T> store, Filter<? super Stub<?>> filter)`

`static

`<T extends DBEntry> ArrayList<Stub<T>>`

`

`DBUtils.listStubs(DBClassStore<T> store, Filter<? super Stub<?>> filter, int maxEntries)`

`ArrayList<User>` `AbstractUserLoginStore.listUsers(Filter<? super User> filter)`
`static ArrayList<User>` `AbstractUserLoginStore.listUsers(UserLoginStore uls, Filter<? super User> filter)` it may be more efficient to achieve this via an embedded DBClassStore if applicable
`static Stub<?>` `DBUtils.loadStub(Database<?> db, DBReference ref)` reloads a reference as a stub, so that the display value is properly initialized.
`String` `LockManager.lock(DBReference ref, String who, String where, String why)`
`User` `UserLoginStore.loginUser(String name, char[] password, String fromLocation)` returns the User that corresponds to the credentials provided; listeners are notified
`User` `AbstractUserLoginStore.loginUser(String name, char[] password, String fromLocation)`
`void` `UserLoginStore.loginUser(User user, String fromLocation)` allows to login a user via API directly
`void` `AbstractUserLoginStore.loginUser(User user, String fromLocation)`
`static void` `AbstractUserLoginStore.logoutAll(UserLoginStore uls)`
`boolean` `UserLoginStore.logoutUser(User user)` logs the given user out of this store and notifies the listeners

`

`<T extends DBEntry> Hashtable<Object,T>`

`

`AbstractDatabase.mapEntries(Class<T> c, Filter<? super T> filter)`
returns a Hashtable mapping the ID to its DBEntry of those that apply to the given filter.

`static

`<T extends DBEntry> Hashtable<Object,T>`

`

`DBUtils.mapEntries(DBClassStore<T> store, Filter<? super T> filter)`

`static

`<T extends DBEntry,P> Hashtable<Object,P>`

`

`DBUtils.mapEntries(DBClassStore<T> store, PatternExtractor<? super T,P> pe, Filter<? super T> filter)`

`

`<T extends DBEntry> Hashtable<Object,Stub<T>>`

`

`AbstractDatabase.mapStubs(Class<T> c, Filter<? super Stub<?>> filter)`
returns a Hashtable mapping the ID to its Stub of those that apply to the given filter.

`static

`<T extends DBEntry> Hashtable<Object,Stub<T>>`

`

`DBUtils.mapStubs(DBClassStore<T> store, Filter<? super Stub<?>> filter)`

`int` `ArchivedStore.moveToArchive(Filter<? super T> filter)` requires transactional context on both stores
`int` `ArchiveDBClassStore.moveToArchive(Filter<? super T> filter)`
`void` `CollectionClassStore.put(T entry)`
`void` `ReadOnlyCacheStore.refreshContent()`
`boolean` `LockManager.release(DBReference ref, String token)`
`void` `Stub.reloadDisplayValue(Database<?> db)`
`void` `Stub.reloadDisplayValue(DBClassStore<T> store)`
`Stub<T>` `Stub.reloadInstance(Database<?> db)`
`Stub<T>` `Stub.reloadInstance(DBClassStore<T> store)`
`static DBEntry` `DBEntrySelection.resolve(DBReference ref, Database<?> db)`

`static

`<T> T`

`

`DBUtils.runInTransaction(Callable<T> call, DBTransaction t, boolean useCommitNotAbort)`
the given task is guaranteed to run in an active transaction, where this method only begins a transaction, if the given transaction is not active, yet.

`static void` `DBUtils.runInTransaction(Task<? extends Exception> task, DBTransaction t, boolean useCommitNotAbort)` the given task is guaranteed to run in an active transaction, where this method only begins a transaction, if the given transaction is not active, yet.
`static User` `JUserLoginPanel.showDialog(String title, Component parent, UserLoginStore uls)` uses the default location
`static User` `JUserLoginPanel.showDialog(String title, Component parent, UserLoginStore uls, Image image, JUserLoginPanel.ImageLocation imageLocation)`
`static User` `JUserLoginPanel.showDialog(String title, Component parent, UserLoginStore uls, String location)`
`static User` `JUserLoginPanel.showDialog(String title, Component parent, UserLoginStore uls, String location, Image image, JUserLoginPanel.ImageLocation imageLocation)`
`static User` `JUserLoginPanel.showDialog(String title, Component parent, UserLoginStore uls, String location, Image image, JUserLoginPanel.ImageLocation imageLocation, String userString, String pwdString)` Upon successful login, the associated user is logged into the UserLoginStore.
`int` `WrappedDBClassStore.size(Filter<? super T> filter)`
`int` `ReadOnlyCacheStore.size(Filter<? super T> filter)`
`int` `DBClassStore.size(Filter<? super T> filter)` returns the total number of T elements in this store based on the given filter (which may be null)
`int` `CollectionClassStore.size(Filter<? super T> filter)`
`int` `ArchiveDBClassStore.size(Filter<? super T> filter)`
`int` `AbstractDBClassStore.size(Filter<? super T> filter)`
`static void` `DBUtils.store(Database<?> db, DBEntry... entries)`
`static void` `DBUtils.store(Database<?> db, Iterator<? extends DBEntry> i)`

`static

`<T extends DBEntry> void`

`

`DBUtils.store(DBClassStore<T> store, Collection<T> entries)`
inserts/updates the given entries in the database depending on whether it already exists

`static

`<T extends DBEntry> void`

`

`DBUtils.store(DBClassStore<T> store, Iterator<T> entries)`
inserts/updates the given entries in the database depending on whether it already exists

`static

`<T extends DBEntry> void`

`

`DBUtils.store(DBClassStore<T> store, T entry)`
inserts/updates the given entry into the database depending on whether it already exists

`

`<T extends DBEntry> void`

`

`AbstractDatabase.store(T... entries)`
inserts/updates the given entries in the database depending on whether it already exists

`boolean` `LockManager.unlock(DBReference ref, String token)`
`void` `WrappedDBClassStore.update(T entry)`
`void` `ReadOnlyStore.update(T entry)`
`void` `ReadOnlyCacheStore.update(T entry)`
`void` `EnumDBStore.update(T entry)`
`void` `DBClassStoreCache.update(T entry)`
`void` `DBClassStore.update(T entry)` updates the given entry in the database.
`void` `CollectionClassStore.update(T entry)`
`void` `ArchiveDBClassStore.update(T entry)`

`static

`<T extends DBEntry,E extends Exception> void`

`

`DBUtils.updateAll(DBClassStore<T> store, Processor<T,E> handler, Filter<? super T> filter)`

`static

`<T extends DBEntry,E extends Exception> void`

`

`DBUtils.updateAll(DBClassStore<T> store, Processor<T,E> handler, Filter<? super T> filter, Monitor mon)`

`static

`<T extends DBEntry> T`

`

`DBUtils.updateEntry(DBClassStore<T> store, T entry)`
the store is used to update the entry and the transaction is committed.

Constructors in com.antelmann.db that throw DatabaseException
`CollectionClassStore(Database<?> db, boolean serialize, Class<T> type, T... entries)`
`CollectionClassStore(Database<?> db, Class<T> type, boolean serialize, Collection<T> col)`
`DefaultDBReference(DBClassStore<?> store, Object referenceID)`

Uses of DatabaseException in com.antelmann.genealogy.db

Methods in com.antelmann.genealogy.db that throw DatabaseException
`static DBClassStore<GPerson.Header>` `GPersonStore.createHeaderStore(Database<Connection> db)`
`protected String` `GIDFactory.generateSessionPrefix()`

Constructors in com.antelmann.genealogy.db that throw DatabaseException
`GPersonRelationStore(Database<Connection> db, IDFactory factory)`
`GPersonStore(Database<Connection> db, IDFactory idFactory)`

Uses of DatabaseException in com.antelmann.image

Methods in com.antelmann.image that throw DatabaseException

`static

`<T extends ImageURLEntry.Thumbnail<?>> JDBCRowStore<T>`

`

`ThumbnailMapper.createStore(Database<Connection> db, Class<T> thumbnailType, Class<? extends ImageURLEntry> imageEntryType, String tableName, String idColumn, String thumbnailColumn, String urlColumn, String displayColumn)`

`

`<TN extends ImageURLEntry.Thumbnail<T>> ThumbnailMapper<TN>`

`

`ImageURLEntrySQLStore.createThumbnailMapper(Class<TN> tnType)`

Constructors in com.antelmann.image that throw DatabaseException
`ImageURLEntryMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, Class<T> type)` uses `BaseRowMapper.getNextIntID()` as id-factory
`ImageURLEntryMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type)`
`ImageURLEntrySQLStore(Database<Connection> database, String tableName, IDFactory idFactory, Class<T> type)` uses 'id' and 'title' for id and display column
`ImageURLEntrySQLStore(Database<Connection> database, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type)`
`ThumbnailMapper(Database<Connection> db, Class<T> thumbnailType, Class<? extends ImageURLEntry> imageEntryType, String tableName, String idColumn, String thumbnailColumn, String urlColumn, String displayColumn)`

Uses of DatabaseException in com.antelmann.io

Methods in com.antelmann.io that throw DatabaseException
`boolean` `FileClassStore.containsID(Object id)`
`int` `FileClassStore.deleteEntries(Filter<? super T> filter)`
`boolean` `FileClassStore.deleteEntry(Object id)`
`DBEnumeration<T>` `FileClassStore.fetch(Filter<? super T> filter)`
`DBEnumeration<Stub<T>>` `FileClassStore.fetchStubs(Filter<? super Stub<?>> filter)`
`String` `FileClassStore.generateNewID()`
`T` `FileClassStore.getEntry(Object id)`
`Stub<T>` `FileClassStore.getStub(Object id)`
`void` `FileClassStore.insert(T entry)`
`Object` `FileClassStore.insertAsNew(T entry)`
`protected T` `FileClassStore.loadEntry(File file)`
`protected Stub<T>` `FileClassStore.loadStub(File file)`
`int` `FileClassStore.size(Filter<? super T> filter)`
`void` `FileClassStore.update(T entry)`

Uses of DatabaseException in com.antelmann.math

Methods in com.antelmann.math that throw DatabaseException

`static

`<T extends DBEntry> void`

`

`DataMatrix.loadMatrix(DataMatrix<T> matrix, DBClassStore<? extends T> store, Filter<? super T> filter, Monitor mon)`
min, max of the given logger must be set explicitly

Uses of DatabaseException in com.antelmann.net.mail

Methods in com.antelmann.net.mail that throw DatabaseException
`boolean` `TableCustomizer.individualizeEmail(Email email, javax.mail.internet.InternetAddress address)`
`boolean` `SQLEmailCustomizer.individualizeEmail(Email email, javax.mail.internet.InternetAddress address)`
`boolean` `EmailCustomizer.individualizeEmail(Email email, javax.mail.internet.InternetAddress address)` this method is called by the `EmailAccount.send()` method to individualize this particular email for given the address.
`void` `MessageEntryMapper.verifyBeforeStore(M entry, boolean isInsert)`

Constructors in com.antelmann.net.mail that throw DatabaseException
`MessageEntryMapper(Database<Connection> db, MappingInfo mi, Class<M> type)`
`MessageEntryMapper(Database<Connection> db, MappingInfo mi, IDFactory idFactory, Class<M> type)`
`MessageEntryMapper(Database<Connection> db, String tableName, String idColumn, String contentColumn, Class<M> type, IDFactory idFactory)`

Uses of DatabaseException in com.antelmann.opengeodb

Methods in com.antelmann.opengeodb that throw DatabaseException
`ArrayList<GeoLocation>` `OpenGeoDB.getRootLocations()`

Constructors in com.antelmann.opengeodb that throw DatabaseException
`OpenGeoDB(Connection con)`
`OpenGeoDB(String server, String dbname, String user, String password)`

Uses of DatabaseException in com.antelmann.servlet

Methods in com.antelmann.servlet that throw DatabaseException
`static User` `ServletUtils.authenticate(javax.servlet.ServletRequest req, UserLoginStore uls, Filter<? super User> filter)` implements authentication via BasicAuth
`User` `UserAuthenticationFilter.getUserFor(javax.servlet.ServletRequest request)`
`static User` `ServletUtils.getUserFromHeader(UserLoginStore uls, javax.servlet.ServletRequest request, String userKey, String pwdKey, boolean hashedPassword, Filter<? super User> filter)`
`static User` `ServletUtils.getUserFromParams(UserLoginStore uls, javax.servlet.ServletRequest request, String userKey, String pwdKey, boolean hashedPassword, Filter<? super User> filter)`

Uses of DatabaseException in com.antelmann.sql

Method parameters in com.antelmann.sql with type arguments of type DatabaseException
`void` `JDBCRowStore.add(Processor<T,? extends DatabaseException> processor)`
`boolean` `JDBCRowStore.remove(Processor<T,? extends DatabaseException> processor)`

Methods in com.antelmann.sql that throw DatabaseException
`protected void` `BaseRowMapper.checkExistence(DBReference ref)`
`static String` `MySqlQueryToViewMapper.checkMySqlViewForQuery(BaseRowMapper<?> mapper, String tableQuery)` checks whether an appropriate view already exists for the given mapper and creates one based on the given query if it doesn't exist.
`boolean` `SQLColumnInfoStore.containsColumnValue(String column, Object value)`
`boolean` `SQLColumnInfo.containsColumnValue(String column, Object value)`
`boolean` `JDBCRowStore.containsID(Object id)`
`int` `SQLColumnInfoStore.countDistinctValues(String column, Map<String,Object> sqlRestrictions)`
`int` `SQLColumnInfo.countDistinctValues(String column, Map<String,Object> sqlRestrictions)`
`int` `RelationshipStore.countRelations(Map<RelationshipManager.Column,Object> restrictions)`
`int` `RelationshipManager.countRelations(Map<RelationshipManager.Column,Object> restrictions)` the mapped values for the class columns `RelationshipManager.Column.TO_CLASS` and `RelationshipManager.Column.FROM_CLASS` may be represented as Class

`static

`<T extends Category.Entry> BaseRowMapper<T>`

`

`CategoryStore.createDefaultMapper(Database<Connection> db, String table, String idColumn, String nameColumn, String parentColumn, IDFactory factory, Class<T> type)`

`static

`<T extends DBEntry> JDBCRowStore<T>`

`

`MappedEntryMapper.createStore(Database<Connection> db, Class<T> type)`
convenience method to easily create a store with no factory

`static

`<T extends DBEntry> JDBCRowStore<T>`

`

`MappedEntryMapper.createStore(Database<Connection> db, Class<T> type, boolean useNextIntForID)`
convenience method to easily create a store and use `BaseRowMapper.getNextIntID()` to implement `BaseRowMapper.generateNewID()`

`static

`<T extends DBEntry> JDBCRowStore<T>`

`

`MappedEntryMapper.createStore(Database<Connection> db, Class<T> type, boolean useNextIntForID, boolean fastDelete)`
convenience method to easily create a store and use `BaseRowMapper.getNextIntID()` to implement `BaseRowMapper.generateNewID()`

`static

`<T extends DBEntry> JDBCRowStore<T>`

`

`MappedEntryMapper.createStore(Database<Connection> db, Class<T> type, IDFactory factory, boolean enableFastDelete)`
convenience method to easily create a store

`int` `SQLColumnInfoStore.deleteEntries(Filter<? super T> filter)`
`int` `JDBCRowStore.deleteEntries(Filter<? super T> filter)` supports SQLMapFilter for more effective deletion.
`int` `DetailRowStore.deleteEntries(Filter<? super T> filter)` Deprecated.
`boolean` `TaggableSQLStore.deleteEntry(Object id)`
`boolean` `PropertyEntryTableStore.deleteEntry(Object id)`
`boolean` `JDBCRowStore.deleteEntry(Object id)`
`boolean` `DetailRowStore.deleteEntry(Object id)` Deprecated.
`boolean` `CategoryStore.deleteEntry(Object id)`
`protected void` `TaggableSQLStore.deleteGroups(Object entryID)`
`protected void` `SQLTransaction.doAbort()`
`protected void` `SQLTransaction.doCommit()`
`DBEnumeration<T>` `JDBCRowStore.fetch(Filter<? super T> filter)` Depending of the capabilities of the mapper in use, this method can support various special filters.
`DBEnumeration<Stub<T>>` `JDBCRowStore.fetchStubs(Filter<? super Stub<?>> filter)` This implementation supports SQLStubFilter and SQLDirectQueryEntryFilter objects; but otherwise, it doesn't filter in any more intelligent way than leaving the filtering to the AbstractIterator.

`static

`<T extends DefaultEntryRelationship> ArrayList<T>`

`

`RelationshipStore.findBrokenRelationships(DBClassStore<T> store, boolean breakOnFirstEncounter)`

`static

`<T extends DefaultEntryRelationship> void`

`

`RelationshipStore.findBrokenRelationships(DBClassStore<T> store, Collection<T> set, Monitor monitor, boolean breakOnFirstEncounter)`
looks for broken relationships in the database and puts them into the given collection.

`static

`<T extends DefaultEntryRelationship> ArrayList<T>`

`

`RelationshipStore.findBrokenRelationships(DBClassStore<T> store, Monitor monitor, boolean breakOnFirstEncounter)`

`DBClassStore<RowItem>` `SQLDatabase.generateGenericClassStore(String table, String idColumn)` generates and returns a generic wrapped DBClassStore on RowItem objects; the store is not put into the database.
`GenericPropertyEntryStore<RowItem>` `SQLDatabase.generateGenericClassStore(String table, String idColumn, String displayColumn)` generates and returns a generic wrapped DBClassStore on RowItem objects; the store is not put into the database (as multiple stores working on different tables could map to the RowItem class).
`Object` `WrappedObjectRowMapper.generateNewID()`
`Object` `UserImplMapper.generateNewID()` if no factory is given, getNextIntID is returned
`Integer` `SerializedEntrySQLMapper.generateNewID()`
`Object` `ObjectRowMapper.generateNewID()`
`Object` `JDBCRowStore.generateNewID()` returns a value supplied by the mapper
`Object` `GenericPropertyEntryMapper.generateNewID()` simply returns getNextIntID(), unless an IDFactory was provided
`Object` `BaseRowMapper.generateNewID()` returns the return value of the given IDFactory or throws UnsupportedOperationException if no IDFactory was supplied
`User[]` `UserImplStore.getActiveUsers()`
`Iterable<Object>` `CategoryStore.getAllSubCategoryIDs(DBReference categoryRef)`
`String[]` `SQLDatabase.getColumnNames(Class<? extends DBEntry> type)` returns all column names that are mapped by the standard query by taking advantage of the `MappingInfo` interface - if applicable
`Hashtable<String,Integer>` `SQLDatabase.getColumnTypes(Class<? extends DBEntry> type)` returns all column names mapped to their respective `Types`.
`Set<?>` `SQLColumnInfoStore.getDistinctValues(String column, Map<String,Object> sqlRestrictions)`
`Set<?>` `SQLColumnInfo.getDistinctValues(String column, Map<String,Object> sqlRestrictions)`
`Map<?,Integer>` `SQLColumnInfoStore.getDistinctValuesWithCount(Map<String,Object> sqlRestrictions, String... column)`
`Map<?,Integer>` `SQLColumnInfo.getDistinctValuesWithCount(Map<String,Object> sqlRestrictions, String... column)`
`T` `JDBCRowStore.getEntry(Object id)`
`T` `DetailRowStore.getEntry(Object id)` Deprecated.
`static TableModelWrapper` `ForeignKeyMappingInfo.Analyzer.getForeignKeys(Database<Connection> db)`
`Object` `SQLColumnInfoStore.getFunctionValueForColumn(String column, SQLFunction func, Map<String,Object> sqlRestrictions)`
`Object` `SQLColumnInfo.getFunctionValueForColumn(String column, SQLFunction func, Map<String,Object> sqlRestrictions)`
`protected List<T>` `CategoryStore.getList(Filter<? super T> filter)`
`int` `SQLColumnInfoStore.getMaxLength(String textColumn, Map<String,Object> sqlRestrictions)`
`int` `SQLColumnInfo.getMaxLength(String textColumn, Map<String,Object> sqlRestrictions)`
`protected Integer` `BaseRowMapper.getNextIntID()` a convenience implementation for easily providing a way of generating new IDs for tables using an integer column as ID column.

`

`<T extends DBEntry> T`

`

`SQLDatabase.getRandomEntry(Class<T> type, Filter<? super T> filter)`

`Stub<T>` `JDBCRowStore.getStub(Object id)`
`List<T>` `CategoryStore.getSubCategories(DBReference categoryRef)`
`String[]` `BaseRowMapper.getTableColumnNames()`
`String[]` `SQLDatabase.getTableNames()`
`List<T>` `CategoryStore.getTopCategories()`
`static Map<Class<? extends DBEntry>,Integer>` `ForeignKeyMappingInfo.Analyzer.getUsage(DBReference ref, Database<?> db)`
`User` `UserImplStore.getUserForName(String name)`
`T` `UserImplMapper.getUserForName(String name)` for use with an AbstractUserLoginStore
`Iterable<String>` `UserImplStore.getUserNames()`
`Iterable<String>` `UserImplMapper.getUserNames()` for use with an AbstractUserLoginStore
`void` `WrappedObjectRowMapper.handleAfterStore(T entry, boolean isInsert)`
`void` `UserImplMapper.handleAfterStore(T entry, boolean isInsert)`
`void` `ObjectRowMapper.handleAfterStore(T entry, boolean isInsert)` called by the store after a given entry is either inserted or updated, so that additional updates (other than providing the RowItem for storage) can take place.
`void` `BaseRowMapper.handleAfterStore(T entry, boolean isInsert)` does nothing unless overridden
`boolean` `RelationshipStore.hasRelationships(DBReference ref)`
`boolean` `RelationshipManager.hasRelationships(DBReference ref)` determines if there are any relationsips present for a given reference (both: active and passive)
`protected void` `TaggableSQLStore.initGroups(T entry)`
`protected void` `BaseRowMapper.initMapping()` responsible for initializing and caching the meta data for the `MappingInfo` interface; note that this method is indirectly called by the constructor
`void` `PropertyEntryTableStore.insert(T entry)`
`void` `JDBCRowStore.insert(T entry)`
`void` `DetailRowStore.insert(T entry)` Deprecated.
`Object` `PropertyEntryTableStore.insertAsNew(T entry)`
`Object` `JDBCRowStore.insertAsNew(T entry)`
`Object` `DetailRowStore.insertAsNew(T entry)` Deprecated.
`static boolean` `ForeignKeyMappingInfo.Analyzer.isInUse(DBReference ref, Database<?> db)`
`boolean` `CategoryStore.isLeaf(DBReference categoryRef)`
`boolean` `CategoryStore.isUsed(DBReference categoryRef)`
`Set<DefaultEntryRelationship>` `RelationshipStore.listAllRelations(DBReference ref, Object relationType)`
`Set<DefaultEntryRelationship>` `RelationshipManager.listAllRelations(DBReference ref, Object relationType)` contains passive and active relationships for the given reference - restricted to the given type if non-null
`List<DefaultEntryRelationship>` `RelationshipStore.listRelations(Map<RelationshipManager.Column,Object> restrictions)`
`List<DefaultEntryRelationship>` `RelationshipManager.listRelations(Map<RelationshipManager.Column,Object> restrictions)` the mapped values for the class columns `RelationshipManager.Column.TO_CLASS` and `RelationshipManager.Column.FROM_CLASS` may be represented as Class
`User` `UserImplStore.loginUser(String name, char[] password, String fromLocation)`
`void` `UserImplStore.loginUser(User user, String fromLocation)`
`boolean` `UserImplStore.logoutUser(User user)`
`int` `SQLColumnInfoStore.replaceColumnValue(String column, Object oldValue, Object newValue, boolean useQueryIfApplicable)`
`int` `SQLColumnInfo.replaceColumnValue(String column, Object oldValue, Object newValue, boolean useQueryIfApplicable)` fires a database update event
`void` `GenericPropertyEntryStore.setRestrictedMappedColumns(String... columns)`
`void` `RelationshipStore.setTableQuery(String query)`
`void` `MySqlQueryToViewMapper.setTableQuery(String tableQuery)`
`void` `GenericPropertyEntryStore.setTableQuery(String query)`
`void` `GenericPropertyEntryMapper.setTableQuery(String tableQuery)`
`protected void` `BaseRowMapper.setTableQuery(String tableQuery)` allows to set a query for mapping the data instead of just using the table name.
`void` `GenericPropertyEntryStore.setTableQuery(String query, String newIdColumn)`
`void` `GenericPropertyEntryMapper.setTableQuery(String tableQuery, String newIdColumn)`
`protected void` `BaseRowMapper.setTableQuery(String tableQuery, String newIdColumn)` in addition to setting a table query, this also allows to change the id column (often required to ensure the uniqueness of the id column in a query that may contain the column multiple times).
`int` `JDBCRowStore.size(Filter<? super T> filter)` supports special performance optimization for SQLMapFilter and some other.
`protected void` `TaggableSQLStore.storeGroups(T entry)`
`protected void` `SortedGroupableSQLStore.storeGroups(T entry)`
`void` `PropertyEntryTableStore.update(T entry)`
`void` `JDBCRowStore.update(T entry)`
`void` `DetailRowStore.update(T entry)` Deprecated.
`void` `WrappedObjectRowMapper.verifyBeforeDelete(Object id)`
`void` `UserImplMapper.verifyBeforeDelete(Object id)`
`void` `ObjectRowMapper.verifyBeforeDelete(Object id)` called by the store before a given entry is deleted, so that additional checks can easily be incorporated.
`void` `BaseRowMapper.verifyBeforeDelete(Object id)` does nothing unless overridden
`void` `BaseDocumentMapper.verifyBeforeDelete(Object id)` if a relationshipManager is set, it is verified that there are no relations to this document
`void` `WrappedObjectRowMapper.verifyBeforeStore(T entry, boolean isInsert)`
`void` `RelationshipStore.Mapper.verifyBeforeStore(T entry, boolean isInsert)`
`void` `ObjectRowMapper.verifyBeforeStore(T entry, boolean isInsert)` called by the store before a given entry is either inserted or updated, so that additional checks can easily be incorporated.
`void` `BaseRowMapper.verifyBeforeStore(T entry, boolean isInsert)` checks whether the filter (if non-null) accepts the entry.

Constructors in com.antelmann.sql that throw DatabaseException
`BaseDocumentMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type, String query)`
`BaseRowMapper(Database<Connection> db, MappingInfo mi, IDFactory idFactory, Class<T> type, Object... topics)` allows to initialize this MappingInfo with the given one.
`BaseRowMapper(Database<Connection> db, String tableName, String idColumn)` the idColumn is also used as the displayColumn
`BaseRowMapper(Database<Connection> db, String tableName, String idColumn, IDFactory idFactory, Class<T> type)`
`BaseRowMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn)`
`BaseRowMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type)`
`BaseRowMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type, String query)` this constructor is eventually called by all others
`BeanMapper(Database<Connection> db, MappingInfo mi, IDFactory idFactory, Class<T> type, Object... topics)`
`BeanMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type, String query)`
`DBDocumentStore.Mapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type, String query)`
`DBDocumentStore(Database<Connection> db, IDFactory idFactory, Class<T> type)` uses a table named 'dokumente'
`DBDocumentStore(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, String query, Class<T> type)`
`GenericPropertyEntryMapper(Database<Connection> db, String table, String idColumn, Class<T> type)` uses reflection to utilize the constructor that takes the ID and then the properties as a map
`GenericPropertyEntryMapper(Database<Connection> db, String table, String idColumn, IDFactory idFactory, Class<T> type)`
`GenericPropertyEntryMapper(Database<Connection> db, String table, String idColumn, PropertyEntryFactory<T> factory, Class<T> type)` uses the factory to generate instances; either factory or type must not be null
`GenericPropertyEntryMapper(Database<Connection> db, String table, String idColumn, String displayColumn, Class<T> type)` uses reflection to utilize the constructor that takes the ID and then the properties as a map
`GenericPropertyEntryMapper(Database<Connection> db, String table, String idColumn, String displayColumn, PropertyEntryFactory<T> factory, Class<T> type)` uses the factory to generate instances; either factory or type must not be null
`GenericPropertyEntryMapper(Database<Connection> db, String table, String idColumn, String displayColumn, PropertyEntryFactory<T> factory, Class<T> type, IDFactory idFactory)` uses the factory to generate instances; either factory or type must not be null
`GenericPropertyEntryMapper(DBClassStore<?> refStore, Class<T> type)`
`GenericPropertyEntryMapper(DBClassStore<?> refStore, PropertyEntryFactory<T> factory, Class<T> type, IDFactory idFactory)`
`GenericPropertyEntryStore(Database<Connection> db, String table, String idColumn, Class<T> type)`
`GenericPropertyEntryStore(Database<Connection> db, String table, String idColumn, Class<T> type, IDFactory idFactory)`
`GenericPropertyEntryStore(Database<Connection> db, String table, String idColumn, PropertyEntryFactory<T> factory, Class<T> type)`
`GenericPropertyEntryStore(Database<Connection> db, String table, String idColumn, String displayColumn, Class<T> type)`
`GenericPropertyEntryStore(Database<Connection> db, String table, String idColumn, String displayColumn, PropertyEntryFactory<T> factory, Class<T> type)`
`GenericPropertyEntryStore(Database<Connection> db, String table, String idColumn, String displayColumn, PropertyEntryFactory<T> factory, Class<T> type, IDFactory idFactory)`
`GenericPropertyEntryStore(DBClassStore<?> refStore, Class<T> type)` takes table, id column, display column names and table query (if applicable) from the given reference store; additionally, new ids are generated through the given store
`GenericPropertyEntryStore(DBClassStore<?> refStore, PropertyEntryFactory<T> factory, Class<T> type, IDFactory idFactory)` takes table, id column, display column names and table query (if applicable) from the given reference store.
`MappedEntryMapper(Database<Connection> db, Class<T> type)`
`MappedEntryMapper(Database<Connection> db, Class<T> type, IDFactory factory)`
`MySqlQueryToViewMapper(Database<Connection> db, MappingInfo mi, IDFactory idFactory, Class<T> type, Object... topics)`
`MySqlQueryToViewMapper(Database<Connection> db, String tableName, String idColumn)`
`MySqlQueryToViewMapper(Database<Connection> db, String tableName, String idColumn, IDFactory idFactory, Class<T> type)`
`MySqlQueryToViewMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn)`
`MySqlQueryToViewMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type)`
`MySqlQueryToViewMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type, String query)`
`PropertyMapper(Database<Connection> db, MappingInfo mi, IDFactory idFactory, Class<T> type, Object... topics)`
`PropertyMapper(Database<Connection> db, String tableName, String idColumn)`
`PropertyMapper(Database<Connection> db, String tableName, String idColumn, IDFactory idFactory, Class<T> type)`
`PropertyMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn)`
`PropertyMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type)`
`PropertyMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type, String query)`
`RelationshipStore.Mapper(Database<Connection> db, String tableName, String idColumn, IDFactory idFactory, Class<T> type)`
`RelationshipStore.Mapper(Database<Connection> db, String tableName, String idColumn, Map<RelationshipManager.Column,String> config, IDFactory idFactory, Class<T> type)`
`RelationshipStore.Mapper(Database<Connection> db, String tableName, String idColumn, Map<RelationshipManager.Column,String> config, IDFactory idFactory, Class<T> type, String query)`
`RelationshipStore(Database<Connection> db, String tableName, String idColumn, Class<T> type, boolean useNextIntAsID)`
`RelationshipStore(Database<Connection> db, String tableName, String idColumn, IDFactory factory, Class<T> type)`
`RelationshipStore(Database<Connection> db, String tableName, String idColumn, Map<RelationshipManager.Column,String> config, Class<T> type, boolean useNextIntAsID)`
`RelationshipStore(Database<Connection> db, String tableName, String idColumn, Map<RelationshipManager.Column,String> config, IDFactory factory, Class<T> type)`
`RelationshipStore(Database<Connection> db, String tableName, String idColumn, Map<RelationshipManager.Column,String> config, IDFactory factory, Class<T> type, String query)`
`SerializedEntrySQLMapper(Database<Connection> db, String tableName, String idColumnName, String displayColumn, String objectStreamColumnName)`
`UnionSqlStore(Class<T> type, Collection<Object> topics, DBClassStore<?>... stores)`
`UnionSqlStore(Class<T> type, DBClassStore<?>... stores)`
`UserImplMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> userType)`

Uses of DatabaseException in com.antelmann.util

Methods in com.antelmann.util that throw DatabaseException
`boolean` `Country.Store.containsID(Object id)`
`int` `Country.Store.deleteEntries(Filter<? super Country> filter)`
`boolean` `Country.Store.deleteEntry(Object id)`
`DBEnumeration<Country>` `Country.Store.fetch(Filter<? super Country> filter)`
`DBEnumeration<Stub<Country>>` `Country.Store.fetchStubs(Filter<? super Stub<?>> filter)`
`Object` `Country.Store.generateNewID()`
`Country` `Country.Store.getEntry(Object id)`
`Stub<Country>` `Country.Store.getStub(Object id)`
`void` `Country.Store.insert(Country entry)`
`Object` `Country.Store.insertAsNew(Country entry)`
`int` `Country.Store.size(Filter<? super Country> filter)`
`void` `Country.Store.update(Country entry)`

Uses of DatabaseException in com.antelmann.util.gui

Methods in com.antelmann.util.gui that throw DatabaseException
`protected List<? extends Keyword>` `JTagsField.getAvailableGroups()`

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