Package lu.kbra.pclib.db.table

Class DatabaseTable<T extends DatabaseEntry>

java.lang.Object

lu.kbra.pclib.db.table.DatabaseTable<T>

All Implemented Interfaces:

SQLQueryable<T>, AbstractDBTable<T>

Direct Known Subclasses:

DBTableProxy, DeferredDatabaseTable

public class DatabaseTable<T extends DatabaseEntry>
extends Object
implements AbstractDBTable<T>

Field Summary

Fields

Modifier and Type	Field	Description
protected Map<String,Object>	customHints
protected Database	database
protected DatabaseEntryUtils	databaseEntryUtils
protected SQLQueryableHookManager	queryableHookManager
protected TableStructure	structure

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	DatabaseTable()
	DatabaseTable(Database database)
	DatabaseTable(Database database, String name)
protected	DatabaseTable(Database database, DatabaseEntryUtils databaseEntryUtils)
protected	DatabaseTable(Database database, DatabaseEntryUtils databaseEntryUtils, Class<? extends AbstractDBTable<T>> tableClass, Map<String,Object> customHints)

Method Summary

Modifier and Type	Method	Description
int	clear()
protected int	clear(AbstractConnection c)
int	count()
protected int	count(AbstractConnection c)
protected int	countNotNull(AbstractConnection c, T data)
int	countNotNull(T data)
protected int	countUniques(AbstractConnection c, T data)
int	countUniques(T data)
DatabaseTableStatus	create()
protected DatabaseTableStatus	create(AbstractConnection c)
DatabaseTable<T>	createProxy(Supplier<AbstractConnection> connection)
protected T	delete(AbstractConnection c, T data)
T	delete(T data)
<C extends Collection<T>> C	deleteAll(C datas)
protected <C extends Collection<T>> C	deleteAll(AbstractConnection c, C datas)
<C extends Collection<T>, D extends Collection<T>> D	deleteAllIfExists(C datas, Supplier<D> supplier)
protected <D extends Collection<T>, C extends Collection<T>> D	deleteIfExists(AbstractConnection c, C datas, Supplier<D> supplier)
protected Optional<T>	deleteIfExists(AbstractConnection c, T data)
Optional<T>	deleteIfExists(T data)
protected Optional<T>	deleteUnique(AbstractConnection c, T data)
Optional<T>	deleteUnique(T data)
protected List<T>	deleteUniques(AbstractConnection c, T data)
List<T>	deleteUniques(T data)
protected String	doubleQuoteEscapeIdentifier(String identifier)
AbstractDBTable<T>	drop()
protected AbstractDBTable<T>	drop(AbstractConnection c)
boolean	exists()
protected boolean	exists(AbstractConnection c)
protected boolean	exists(AbstractConnection c, T data)
boolean	exists(T data)
protected boolean	existsUnique(AbstractConnection c, T data)
boolean	existsUnique(T data)
protected boolean	existsUniques(AbstractConnection c, T data)
boolean	existsUniques(T data)
<C extends Collection<T>, D extends Collection<T>> D	filterExists(C datas, Supplier<D> supplier)
protected <C extends Collection<T>, D extends Collection<T>> D	filterExists(AbstractConnection c, C datas, Supplier<D> supplier)
<C extends Collection<T>, D extends Collection<T>> D	filterExistsByUnique(C datas, Supplier<D> supplier)
protected <D extends Collection<T>, C extends Collection<T>> D	filterExistsByUnique(AbstractConnection c, C datas, Supplier<D> supplier)
<C extends Collection<T>, D extends Collection<T>> D	filterExistsUnique(C datas, Supplier<D> supplier)
protected <D extends Collection<T>, C extends Collection<T>> D	filterExistsUnique(AbstractConnection c, C datas, Supplier<D> supplier)
DatabaseConnector	getConnector()
String[]	getCreateSQL()
final Class<T>	getEntryClass()
final String	getName()
final String	getQualifiedName()
protected AbstractDBTable<T>	getQueryable()
final Class<? extends SQLQueryable<T>>	getTargetClass()
protected T	insert(AbstractConnection c, T data)
T	insert(T data)
<C extends Collection<T>> C	insertAll(C data)
protected <C extends Collection<T>> C	insertAll(AbstractConnection c, C datas)
protected T	insertAndReload(AbstractConnection c, T data)
T	insertAndReload(T data)
<C extends Collection<T>> C	insertAndReloadAll(C datas)
protected <C extends Collection<T>> C	insertAndReloadAll(AbstractConnection c, C datas)
protected T	load(AbstractConnection c, T data)
T	load(T data)
<C extends Collection<T>> C	loadAll(C datas)
protected <C extends Collection<T>> C	loadAll(AbstractConnection c, C datas)
<C extends Collection<T>, D extends Collection<T>> D	loadAllByUnique(C datas, Supplier<D> supplier)
protected <C extends Collection<T>, D extends Collection<T>> D	loadAllByUnique(AbstractConnection c, C datas, Supplier<D> supplier)
<C extends Collection<T>, D extends Collection<T>> D	loadAllIfExists(C datas, Supplier<D> supplier)
<C extends Collection<T>> C	loadAllUnique(C datas)
protected <C extends Collection<T>> C	loadAllUnique(AbstractConnection c, C datas)
protected List<T>	loadByUnique(AbstractConnection c, T data)
List<T>	loadByUnique(T data)	Returns a list of all the possible entries matching with the unique values of the input.
protected <C extends Collection<T>, D extends Collection<T>> D	loadIfExists(AbstractConnection c, C datas, Supplier<D> supplier)
protected Optional<T>	loadIfExists(AbstractConnection c, T data)
Optional<T>	loadIfExists(T data)
protected T	loadIfExistsElseInsert(AbstractConnection c, T data)
T	loadIfExistsElseInsert(T data)	Loads the first pk result, returns a the newly inserted instance if none is found
protected T	loadUnique(AbstractConnection c, T data)
T	loadUnique(T data)	Loads the first unique result, or throws an exception if none is found.
protected Optional<T>	loadUniqueIfExists(AbstractConnection c, T data)
Optional<T>	loadUniqueIfExists(T data)	Loads the first unique result, returns null if none is found and throws an exception if too many are available.
protected T	loadUniqueIfExistsElseInsert(AbstractConnection c, T data)
T	loadUniqueIfExistsElseInsert(T data)	Loads the first unique result, returns a the newly inserted instance if none is found and throws an exception if too many are available.
protected T	loadUniqueIfExistsElseInsertAndReload(AbstractConnection c, T data)
T	loadUniqueIfExistsElseInsertAndReload(T data)	Loads the first unique result, returns null if none is found and throws an exception if too many are available.
protected T	loadUniqueInternal(AbstractConnection c, T data)
protected <B> B	query(AbstractConnection c, SQLQuery<T,B> query)
<B> B	query(SQLQuery<T,B> query)
void	setDbEntryUtils(DatabaseEntryUtils dbEntryUtils)
void	setTableStructure(TableStructure tableStructure)
String	toString()
int	truncate()
protected int	truncate(AbstractConnection c)
protected T	update(AbstractConnection c, T data)
T	update(T data)
<C extends Collection<T>> C	updateAll(C datas)
protected <C extends Collection<T>> C	updateAll(AbstractConnection c, C datas)
protected T	updateAndReload(AbstractConnection c, T data)
T	updateAndReload(T data)
<C extends Collection<T>> C	updateAndReloadAll(C datas)
protected <C extends Collection<T>> C	updateAndReloadAll(AbstractConnection c, C datas)
protected Optional<T>	updateAndReloadIfExists(AbstractConnection c, T data)
Optional<T>	updateAndReloadIfExists(T data)
protected T	updateAndReloadIfExistsElseInsert(AbstractConnection c, T data)
T	updateAndReloadIfExistsElseInsert(T data)
protected T	updateAndReloadIfExistsElseInsertAndReload(AbstractConnection c, T data)
T	updateAndReloadIfExistsElseInsertAndReload(T data)
protected Optional<T>	updateIfExists(AbstractConnection c, T data)
Optional<T>	updateIfExists(T data)
protected T	updateIfExistsElseInsert(AbstractConnection c, T data)
T	updateIfExistsElseInsert(T data)
protected T	updateIfExistsElseInsertAndReload(AbstractConnection c, T data)
T	updateIfExistsElseInsertAndReload(T data)
protected AbstractConnection	use()
protected void	validateStructure()
protected void	validateWrite()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface lu.kbra.pclib.db.table.AbstractDBTable

getCustomHints, getDatabase, getQueryableHookManager, getStructure, setQueryableHookManager

Methods inherited from interface lu.kbra.pclib.db.impl.SQLQueryable

getDatabaseEntryUtils, getStatementAsSQL

Field Details

database

protected Database database

databaseEntryUtils

protected DatabaseEntryUtils databaseEntryUtils

structure

protected TableStructure structure

customHints

protected Map<String,Object> customHints

queryableHookManager

protected SQLQueryableHookManager queryableHookManager

Constructor Details

DatabaseTable

protected DatabaseTable()

DatabaseTable

public DatabaseTable(Database database)

DatabaseTable

protected DatabaseTable(Database database,
 DatabaseEntryUtils databaseEntryUtils)

DatabaseTable

protected DatabaseTable(Database database,
 DatabaseEntryUtils databaseEntryUtils,
 Class<? extends AbstractDBTable<T>> tableClass,
 Map<String,Object> customHints)

DatabaseTable

public DatabaseTable(Database database,
 String name)

Method Details

clear

public int clear()
          throws DBException

Specified by:

clear in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

clear

protected int clear(AbstractConnection c)
             throws DBException

Throws:

DBException

count

public int count()
          throws DBException

Specified by:

count in interface SQLQueryable<T extends DatabaseEntry>

Throws:

DBException

count

protected int count(AbstractConnection c)
             throws DBException

Throws:

DBException

countNotNull

protected int countNotNull(AbstractConnection c,
 T data)
                    throws DBException

Throws:

DBException

countNotNull

public int countNotNull(T data)
                 throws DBException

Specified by:

countNotNull in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

countUniques

protected int countUniques(AbstractConnection c,
 T data)
                    throws DBException

Throws:

DBException

countUniques

public int countUniques(T data)
                 throws DBException

Specified by:

countUniques in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

create

public DatabaseTableStatus create()
                           throws DBException

Specified by:

create in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

create

protected DatabaseTableStatus create(AbstractConnection c)
                              throws DBException

Throws:

DBException

createProxy

public DatabaseTable<T> createProxy(Supplier<AbstractConnection> connection)

delete

protected T delete(AbstractConnection c,
 T data)
            throws DBException

Throws:

DBException

delete

public T delete(T data)
         throws DBException

Specified by:

delete in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

deleteAll

public <C extends Collection<T>> C deleteAll(C datas)
                                      throws DBException

Specified by:

deleteAll in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

deleteAll

protected <C extends Collection<T>> C deleteAll(AbstractConnection c,
 C datas)

deleteIfExists

protected <D extends Collection<T>,
C extends Collection<T>>
D deleteIfExists(AbstractConnection c,
 C datas,
 Supplier<D> supplier)

deleteAllIfExists

public <C extends Collection<T>,
D extends Collection<T>>
D deleteAllIfExists(C datas,
 Supplier<D> supplier)
             throws DBException

Specified by:

deleteAllIfExists in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

deleteIfExists

protected Optional<T> deleteIfExists(AbstractConnection c,
 T data)
                              throws DBException

Throws:

DBException

deleteIfExists

public Optional<T> deleteIfExists(T data)
                           throws DBException

Specified by:

deleteIfExists in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

deleteUnique

protected Optional<T> deleteUnique(AbstractConnection c,
 T data)
                            throws DBException

Throws:

DBException

deleteUnique

public Optional<T> deleteUnique(T data)
                         throws DBException

Specified by:

deleteUnique in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

deleteUniques

protected List<T> deleteUniques(AbstractConnection c,
 T data)
                         throws DBException

Throws:

DBException

deleteUniques

public List<T> deleteUniques(T data)
                      throws DBException

Specified by:

deleteUniques in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

doubleQuoteEscapeIdentifier

protected String doubleQuoteEscapeIdentifier(String identifier)

drop

public AbstractDBTable<T> drop()
                        throws DBException

Specified by:

drop in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

drop

protected AbstractDBTable<T> drop(AbstractConnection c)
                           throws DBException

Throws:

DBException

exists

public boolean exists()
               throws DBException

Specified by:

exists in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

exists

protected boolean exists(AbstractConnection c)
                  throws DBException

Throws:

DBException

exists

protected boolean exists(AbstractConnection c,
 T data)
                  throws DBException

Throws:

DBException

exists

public boolean exists(T data)
               throws DBException

Specified by:

exists in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

existsUnique

protected boolean existsUnique(AbstractConnection c,
 T data)
                        throws DBException

Throws:

DBException

existsUnique

public boolean existsUnique(T data)
                     throws DBException

Specified by:

existsUnique in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

existsUniques

protected boolean existsUniques(AbstractConnection c,
 T data)
                         throws DBException

Throws:

DBException

existsUniques

public boolean existsUniques(T data)
                      throws DBException

Specified by:

existsUniques in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

filterExists

public <C extends Collection<T>,
D extends Collection<T>>
D filterExists(C datas,
 Supplier<D> supplier)
        throws DBException

Specified by:

filterExists in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

filterExists

protected <C extends Collection<T>,
D extends Collection<T>>
D filterExists(AbstractConnection c,
 C datas,
 Supplier<D> supplier)

filterExistsUnique

protected <D extends Collection<T>,
C extends Collection<T>>
D filterExistsUnique(AbstractConnection c,
 C datas,
 Supplier<D> supplier)

filterExistsUnique

public <C extends Collection<T>,
D extends Collection<T>>
D filterExistsUnique(C datas,
 Supplier<D> supplier)
              throws DBException

Specified by:

filterExistsUnique in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

getConnector

public DatabaseConnector getConnector()

Specified by:

getConnector in interface SQLQueryable<T extends DatabaseEntry>

getCreateSQL

public String[] getCreateSQL()

Specified by:

getCreateSQL in interface AbstractDBTable<T extends DatabaseEntry>

getEntryClass

public final Class<T> getEntryClass()

Specified by:

getEntryClass in interface SQLQueryable<T extends DatabaseEntry>

getName

public final String getName()

Specified by:

getName in interface SQLQueryable<T extends DatabaseEntry>

getQualifiedName

public final String getQualifiedName()

Specified by:

getQualifiedName in interface SQLQueryable<T extends DatabaseEntry>

getQueryable

protected AbstractDBTable<T> getQueryable()

getTargetClass

public final Class<? extends SQLQueryable<T>> getTargetClass()

Specified by:

getTargetClass in interface SQLQueryable<T extends DatabaseEntry>

insert

protected T insert(AbstractConnection c,
 T data)
            throws DBException

Throws:

DBException

insert

public T insert(T data)
         throws DBException

Specified by:

insert in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

insertAll

public <C extends Collection<T>> C insertAll(C data)
                                      throws DBException

Specified by:

insertAll in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

insertAll

protected <C extends Collection<T>> C insertAll(AbstractConnection c,
 C datas)

insertAndReload

protected T insertAndReload(AbstractConnection c,
 T data)
                     throws DBException

Throws:

DBException

insertAndReload

public T insertAndReload(T data)
                  throws DBException

Specified by:

insertAndReload in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

insertAndReloadAll

public <C extends Collection<T>> C insertAndReloadAll(C datas)
                                               throws DBException

Specified by:

insertAndReloadAll in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

insertAndReloadAll

protected <C extends Collection<T>> C insertAndReloadAll(AbstractConnection c,
 C datas)

load

protected T load(AbstractConnection c,
 T data)
          throws DBException

Throws:

DBException

load

public T load(T data)
       throws DBException

Specified by:

load in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

loadAll

public <C extends Collection<T>> C loadAll(C datas)
                                    throws DBException

Specified by:

loadAll in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

loadAll

protected <C extends Collection<T>> C loadAll(AbstractConnection c,
 C datas)

loadByUnique

protected List<T> loadByUnique(AbstractConnection c,
 T data)
                        throws DBException

Throws:

DBException

loadByUnique

public List<T> loadByUnique(T data)
                     throws DBException

Returns a list of all the possible entries matching with the unique values of the input.

Specified by:

loadByUnique in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

loadIfExists

protected <C extends Collection<T>,
D extends Collection<T>>
D loadIfExists(AbstractConnection c,
 C datas,
 Supplier<D> supplier)

loadAllIfExists

public <C extends Collection<T>,
D extends Collection<T>>
D loadAllIfExists(C datas,
 Supplier<D> supplier)
           throws DBException

Specified by:

loadAllIfExists in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

loadIfExists

protected Optional<T> loadIfExists(AbstractConnection c,
 T data)
                            throws DBException

Throws:

DBException

updateIfExistsElseInsertAndReload

public T updateIfExistsElseInsertAndReload(T data)

Specified by:

updateIfExistsElseInsertAndReload in interface AbstractDBTable<T extends DatabaseEntry>

updateIfExistsElseInsertAndReload

protected T updateIfExistsElseInsertAndReload(AbstractConnection c,
 T data)

updateIfExistsElseInsert

public T updateIfExistsElseInsert(T data)

Specified by:

updateIfExistsElseInsert in interface AbstractDBTable<T extends DatabaseEntry>

updateIfExistsElseInsert

protected T updateIfExistsElseInsert(AbstractConnection c,
 T data)

updateIfExists

public Optional<T> updateIfExists(T data)

Specified by:

updateIfExists in interface AbstractDBTable<T extends DatabaseEntry>

updateIfExists

protected Optional<T> updateIfExists(AbstractConnection c,
 T data)

updateAndReloadIfExistsElseInsertAndReload

public T updateAndReloadIfExistsElseInsertAndReload(T data)

Specified by:

updateAndReloadIfExistsElseInsertAndReload in interface AbstractDBTable<T extends DatabaseEntry>

updateAndReloadIfExistsElseInsertAndReload

protected T updateAndReloadIfExistsElseInsertAndReload(AbstractConnection c,
 T data)

updateAndReloadIfExistsElseInsert

public T updateAndReloadIfExistsElseInsert(T data)

Specified by:

updateAndReloadIfExistsElseInsert in interface AbstractDBTable<T extends DatabaseEntry>

updateAndReloadIfExistsElseInsert

protected T updateAndReloadIfExistsElseInsert(AbstractConnection c,
 T data)

updateAndReloadIfExists

public Optional<T> updateAndReloadIfExists(T data)

Specified by:

updateAndReloadIfExists in interface AbstractDBTable<T extends DatabaseEntry>

updateAndReloadIfExists

protected Optional<T> updateAndReloadIfExists(AbstractConnection c,
 T data)

loadIfExists

public Optional<T> loadIfExists(T data)
                         throws DBException

Specified by:

loadIfExists in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

loadIfExistsElseInsert

protected T loadIfExistsElseInsert(AbstractConnection c,
 T data)
                            throws DBException

Throws:

DBException

loadIfExistsElseInsert

public T loadIfExistsElseInsert(T data)
                         throws DBException

Loads the first pk result, returns a the newly inserted instance if none is found

Throws:

DBException

loadUnique

protected T loadUnique(AbstractConnection c,
 T data)
                throws DBException

Throws:

DBException

loadUnique

public T loadUnique(T data)
             throws DBException

Loads the first unique result, or throws an exception if none is found.

Specified by:

loadUnique in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

loadUniqueIfExists

protected Optional<T> loadUniqueIfExists(AbstractConnection c,
 T data)
                                  throws DBException

Throws:

DBException

loadUniqueIfExists

public Optional<T> loadUniqueIfExists(T data)
                               throws DBException

Loads the first unique result, returns null if none is found and throws an exception if too many are available.

Specified by:

loadUniqueIfExists in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

loadUniqueIfExistsElseInsert

protected T loadUniqueIfExistsElseInsert(AbstractConnection c,
 T data)
                                  throws DBException

Throws:

DBException

loadUniqueIfExistsElseInsertAndReload

public T loadUniqueIfExistsElseInsertAndReload(T data)
                                        throws DBException

Loads the first unique result, returns null if none is found and throws an exception if too many are available.

Specified by:

loadUniqueIfExistsElseInsertAndReload in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

loadUniqueIfExistsElseInsertAndReload

protected T loadUniqueIfExistsElseInsertAndReload(AbstractConnection c,
 T data)
                                           throws DBException

Throws:

DBException

loadUniqueIfExistsElseInsert

public T loadUniqueIfExistsElseInsert(T data)
                               throws DBException

Loads the first unique result, returns a the newly inserted instance if none is found and throws an exception if too many are available.

Specified by:

loadUniqueIfExistsElseInsert in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

loadUniqueInternal

protected T loadUniqueInternal(AbstractConnection c,
 T data)

query

protected <B> B query(AbstractConnection c,
 SQLQuery<T,B> query)
               throws DBException

Throws:

DBException

query

public <B> B query(SQLQuery<T,B> query)
            throws DBException

Specified by:

query in interface SQLQueryable<T extends DatabaseEntry>

Throws:

DBException

setDbEntryUtils

public void setDbEntryUtils(DatabaseEntryUtils dbEntryUtils)

setTableStructure

public void setTableStructure(TableStructure tableStructure)

Specified by:

setTableStructure in interface AbstractDBTable<T extends DatabaseEntry>

truncate

public int truncate()
             throws DBException

Specified by:

truncate in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

truncate

protected int truncate(AbstractConnection c)
                throws DBException

Throws:

DBException

update

protected T update(AbstractConnection c,
 T data)
            throws DBException

Throws:

DBException

update

public T update(T data)
         throws DBException

Specified by:

update in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

updateAll

public <C extends Collection<T>> C updateAll(C datas)
                                      throws DBException

Specified by:

updateAll in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

updateAll

protected <C extends Collection<T>> C updateAll(AbstractConnection c,
 C datas)

updateAndReload

protected T updateAndReload(AbstractConnection c,
 T data)
                     throws DBException

Throws:

DBException

updateAndReload

public T updateAndReload(T data)
                  throws DBException

Specified by:

updateAndReload in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

updateAndReloadAll

public <C extends Collection<T>> C updateAndReloadAll(C datas)
                                               throws DBException

Specified by:

updateAndReloadAll in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

updateAndReloadAll

protected <C extends Collection<T>> C updateAndReloadAll(AbstractConnection c,
 C datas)

loadAllUnique

public <C extends Collection<T>> C loadAllUnique(C datas)
                                          throws DBException

Specified by:

loadAllUnique in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

loadAllUnique

protected <C extends Collection<T>> C loadAllUnique(AbstractConnection c,
 C datas)

loadAllByUnique

public <C extends Collection<T>,
D extends Collection<T>>
D loadAllByUnique(C datas,
 Supplier<D> supplier)
           throws DBException

Specified by:

loadAllByUnique in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

loadAllByUnique

protected <C extends Collection<T>,
D extends Collection<T>>
D loadAllByUnique(AbstractConnection c,
 C datas,
 Supplier<D> supplier)

filterExistsByUnique

public <C extends Collection<T>,
D extends Collection<T>>
D filterExistsByUnique(C datas,
 Supplier<D> supplier)
                throws DBException

Specified by:

filterExistsByUnique in interface AbstractDBTable<T extends DatabaseEntry>

Throws:

DBException

filterExistsByUnique

protected <D extends Collection<T>,
C extends Collection<T>>
D filterExistsByUnique(AbstractConnection c,
 C datas,
 Supplier<D> supplier)

use

protected AbstractConnection use()
                          throws DBException

Throws:

DBException

validateStructure

protected void validateStructure()

validateWrite

protected void validateWrite()

toString

public String toString()

Overrides:

toString in class Object