AbstractDatabaseEngine (pdb 2.0.1 API)

java.lang.Object
- com.feedzai.commons.sql.abstraction.engine.AbstractDatabaseEngine

All Implemented Interfaces:

DatabaseEngine

Direct Known Subclasses:

DB2Engine, H2Engine, MySqlEngine, OracleEngine, PostgreSqlEngine, SqlServerEngine
```
public abstract class AbstractDatabaseEngine
extends Object
implements DatabaseEngine
```
Provides a set of functions to interact with the database.
This Engine already provides thread safeness to all public exposed methods

Since:

2.0.0

Author:

Rui Vilao (rui.vilao@feedzai.com)

Field Summary

Fields
Modifier and Type	Field and Description
`protected Connection`	`conn` The database connection.
`protected static org.slf4j.Marker`	`dev` The dev Marker.
`protected Dialect`	`diaclect` The dialect.
`protected ExceptionHandler`	`eh` The exception handler to control the flow when defining new entities.
`protected Map<String,MappedEntity>`	`entities` Map of entities.
`protected com.google.inject.Injector`	`injector` The Guice injector.
`protected org.slf4j.Logger`	`logger` The logger that will be used.
`protected org.slf4j.Logger`	`notificationLogger` The notification logger for administration.
`protected PdbProperties`	`properties` The configuration.
`protected Map<String,PreparedStatementCapsule>`	`stmts` Map of prepared statements.
`protected AbstractTranslator`	`translator` The translator in place.

Constructor Summary

Constructors
Constructor and Description
`AbstractDatabaseEngine(String driver, PdbProperties properties, Dialect dialect)` Creates a new instance of `AbstractDatabaseEngine`.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addBatch(String name, EntityEntry entry)` Add an entry to the batch.
`protected abstract void`	`addColumn(DbEntity entity, DbColumn... columns)` Adds the column to an existent table.
`void`	`addEntity(DbEntity entity)` Adds an entity to the engine.
`protected abstract void`	`addFks(DbEntity entity)` Adds the FKs.
`protected abstract void`	`addIndexes(DbEntity entity)` Add the desired indexes.
`protected abstract void`	`addPrimaryKey(DbEntity entity)` Add a primary key to the entity.
`protected abstract void`	`addSequences(DbEntity entity)` Adds the necessary sequences.
`void`	`beginTransaction()` Starts a transaction.
`boolean`	`checkConnection()` Checks if the connection is alive.
`boolean`	`checkConnection(boolean forceReconnect)` Checks if the connection is alive.
`protected abstract boolean`	`checkConnection(Connection conn)` Checks if the connection is alive.
`void`	`clearParameters(String name)` Clears the prepared statement parameters.
`void`	`close()` Closes the connection to the database.
`String`	`commentCharacter()`
`void`	`commit()` Commits the current transaction.
`protected void`	`connect()` Connects to the database.
`boolean`	`containsEntity(String name)` Returns if the current engine contains the entity.
`AbstractBatch`	`createBatch(int batchSize, long batchTimeout)` Creates a new batch that periodically flushes a batch.
`AbstractBatch`	`createBatch(int batchSize, long batchTimeout, String batchName)` Creates a new batch that periodically flushes a batch.
`void`	`createPreparedStatement(String name, Expression query)` Creates a prepared statement.
`void`	`createPreparedStatement(String name, Expression query, int timeout)` Creates a prepared statement.
`void`	`createPreparedStatement(String name, String query)` Creates a prepared statement.
`void`	`createPreparedStatement(String name, String query, int timeout)` Creates a prepared statement.
`protected abstract MappedEntity`	`createPreparedStatementForInserts(DbEntity entity)` Creates and gets the prepared statement that will be used for insertions.
`protected abstract ResultIterator`	`createResultIterator(PreparedStatement ps)` Creates a specific `ResultIterator` for the engine in place given given prepared statement.
`protected abstract ResultIterator`	`createResultIterator(Statement statement, String sql)` Creates a specific `ResultIterator` given the engine implementation.
`protected abstract void`	`createTable(DbEntity entity)` Creates the table.
`protected abstract void`	`dropColumn(DbEntity entity, String... columns)` Drops the column.
`void`	`dropEntity(DbEntity entity)` Drops everything that belongs to the entity.
`void`	`dropEntity(String entity)` Drops an entity.
`protected void`	`dropFks(String table)` Drops this table foreign keys.
`protected abstract void`	`dropSequences(DbEntity entity)` Drops the sequences of the entity.
`protected abstract void`	`dropTable(DbEntity entity)` Drops the table.
`DatabaseEngine`	`duplicate(Properties mergeProperties, boolean copyEntities)` Duplicates a connection.
`protected abstract int`	`entityToPreparedStatement(DbEntity entity, PreparedStatement ps, EntityEntry entry, boolean useAutoIncs)` Translates the given entry entity to the prepared statement.
`String`	`escapeCharacter()`
`void`	`executePS(String name)` Executes the specified prepared statement.
`Integer`	`executePSUpdate(String name)` Executes update on the specified prepared statement.
`int`	`executeUpdate(Expression query)` Executes the given update.
`int`	`executeUpdate(String query)` Executes a native query.
`protected void`	`executeUpdateSilently(String statement)` Executes the given statement.
`void`	`flush()` Flushes the batches for all the registered entities.
`Connection`	`getConnection()` Checks if the connection is available and returns it.
`Dialect`	`getDialect()` Gets the dialect being used.
`Map<String,DbEntityType>`	`getEntities()` Gets the database entities.
`protected String`	`getFinalJdbcConnection(String jdbc)` Gets the final JDBC connection.
`Map<String,DbColumnType>`	`getMetadata(String name)` Gets the table metadata.
`PdbProperties`	`getProperties()` Gets the properties in use.
`ResultIterator`	`getPSIterator(String name)` Creates an iterator for the `PreparedStatement` bound to the given name.
`List<Map<String,ResultColumn>>`	`getPSResultSet(String name)` Gets the result set of the specified prepared statement.
`Map<String,DbColumnType>`	`getQueryMetadata(Expression query)` Gets the query metadata.
`Map<String,DbColumnType>`	`getQueryMetadata(String query)` Gets the query metadata.
`protected String`	`getSchema()` Gets the schema.
`abstract Class<? extends AbstractTranslator>`	`getTranslatorClass()` Gets the class that translates SQL bound to this engine.
`protected void`	`handleOperation(OperationFault op, Exception e)` Controls if the given faulty operation must be silenced or not.
`boolean`	`hasIdentityColumn(DbEntity entity)` Check if the entity has an identity column.
`protected void`	`inject(Expression... objs)`
`boolean`	`isTransactionActive()` Checks if a transaction is active.
`ResultIterator`	`iterator(Expression query)` Creates an iterator for the given SQL expression.
`ResultIterator`	`iterator(String query)` Creates an iterator for the given SQL sentence.
`protected byte[]`	`objectToArray(Object val)` Converts an object to byte array.
`abstract Long`	`persist(String name, EntityEntry entry)` Persists a given entry.
`abstract Long`	`persist(String name, EntityEntry entry, boolean useAutoInc)` Persists a given entry.
`boolean`	`preparedStatementExists(String name)` Checks if there's a prepared statement with the given name.
`protected List<Map<String,ResultColumn>>`	`processResultIterator(ResultIterator it)` Process a whole `ResultIterator`.
`List<Map<String,ResultColumn>>`	`query(Expression query)` Executes the given query.
`List<Map<String,ResultColumn>>`	`query(String query)` Executes the given query.
`DbEntity`	`removeEntity(String name)` Removes the entity given the name.
`void`	`removePreparedStatement(String name)` Removes the given prepared statement.
`void`	`rollback()` Rolls back a transaction.
`void`	`setExceptionHandler(ExceptionHandler eh)` Sets the given exception handler in the engine.
`void`	`setParameter(String name, int index, Object param)` Sets the parameter on the specified index.
`void`	`setParameters(String name, Object... params)` Sets the parameters on the specified prepared statement.
`protected void`	`setTransactionIsolation()` Sets the transaction isolation level.
`protected DbColumnType`	`toPdbType(int type)` Maps the database type to `DbColumnType`.
`String`	`translate(Expression query)` Translates the given expression to the current dialect.
`protected abstract String`	`translateType(DbColumn c)` Translates the type present in the given column.
`void`	`updateEntity(DbEntity entity)` Updates an entity in the engine.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - injector
```
@Inject
protected com.google.inject.Injector injector
```
    The Guice injector.
  - translator
```
@Inject
protected AbstractTranslator translator
```
    The translator in place.
  - conn
```
protected Connection conn
```
    The database connection.
  - dev
```
protected static final org.slf4j.Marker dev
```
    The dev Marker.
  - logger
```
protected org.slf4j.Logger logger
```
    The logger that will be used.
  - notificationLogger
```
protected org.slf4j.Logger notificationLogger
```
    The notification logger for administration.
  - entities
```
protected final Map<String,MappedEntity> entities
```
    Map of entities.
  - stmts
```
protected final Map<String,PreparedStatementCapsule> stmts
```
    Map of prepared statements.
  - properties
```
protected final PdbProperties properties
```
    The configuration.
  - diaclect
```
protected final Dialect diaclect
```
    The dialect.
  - eh
```
protected ExceptionHandler eh
```
    The exception handler to control the flow when defining new entities.
- Constructor Detail
  - AbstractDatabaseEngine
```
public AbstractDatabaseEngine(String driver,
                      PdbProperties properties,
                      Dialect dialect)
                       throws DatabaseEngineException
```
    Creates a new instance of AbstractDatabaseEngine.
    
    Parameters:
    driver - The driver to connect to the database.
    properties - The properties of the connection.
    dialect - The dialect in use.
    
    Throws:
    
    DatabaseEngineException - When errors occur trying to set up the database connection.
- Method Detail
  - connect
```
protected void connect()
                throws Exception
```
    Connects to the database.
    
    Throws:
    
    Exception - If connection is not possible, or failed to decrypt username/password if encryption was provided.
  - getFinalJdbcConnection
```
protected String getFinalJdbcConnection(String jdbc)
```
    Gets the final JDBC connection.
    Implementations might override this method in order to change the JDBC connection.
    
    Parameters:
    jdbc - The current JDBC connection.
    
    Returns:
    The final JDBC connection.
  - setTransactionIsolation
```
protected void setTransactionIsolation()
                                throws SQLException
```
    Sets the transaction isolation level.
    
    Throws:
    
    SQLException - If a database access error occurs.
  - getTranslatorClass
```
public abstract Class<? extends AbstractTranslator> getTranslatorClass()
```
    Gets the class that translates SQL bound to this engine.
    
    Returns:
    The class that translates SQL bound to this engine.
  - getConnection
```
public Connection getConnection()
                         throws RetryLimitExceededException,
                                InterruptedException,
                                RecoveryException
```
    Checks if the connection is available and returns it. If the connection is not available, it tries to reconnect (the number of times defined in the properties with the delay there specified).
    
    Specified by:
    
    getConnection in interface DatabaseEngine
    
    Returns:
    The connection.
    
    Throws:
    
    RetryLimitExceededException - If the retry limit is exceeded.
    
    InterruptedException - If the thread is interrupted during reconnection.
    
    RecoveryException
  - close
```
public void close()
```
    Closes the connection to the database.
    
    Specified by:
    
    close in interface DatabaseEngine
  - beginTransaction
```
public void beginTransaction()
                      throws DatabaseEngineRuntimeException
```
    Starts a transaction. Doing this will set auto commit to false (Connection.getAutoCommit()).
    
    Specified by:
    
    beginTransaction in interface DatabaseEngine
    
    Throws:
    
    DatabaseEngineException - If something goes wrong while persisting data.
    
    DatabaseEngineRuntimeException
  - addEntity
```
public void addEntity(DbEntity entity)
               throws DatabaseEngineException
```
    Adds an entity to the engine. It will create tables and everything necessary so persistence can work.
    
    Specified by:
    
    addEntity in interface DatabaseEngine
    
    Parameters:
    entity - The entity to add.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong while creating the structures.
  - updateEntity
```
public void updateEntity(DbEntity entity)
                  throws DatabaseEngineException
```
    Updates an entity in the engine.
    
    If the entity does not exist in the instance, the method addEntity(com.feedzai.commons.sql.abstraction.ddl.DbEntity) will be invoked.
    
    The engine will compare the entity with the getMetadata(String) information and update the schema of the table.
    
    ATTENTION: This method will only add new columns or drop removed columns in the database table. It will also drop and create foreign keys. Primary Keys, Indexes and column types changes will not be updated.
    
    Specified by:
    
    updateEntity in interface DatabaseEngine
    
    Parameters:
    entity - The entity to update.
    
    Throws:
    
    DatabaseEngineException
    Since:
    
    12.1.0
  - removeEntity
```
public DbEntity removeEntity(String name)
```
    Description copied from interface: DatabaseEngine
    
    Removes the entity given the name. If the schema is drop-create then the entity will be dropped.
    
    Specified by:
    
    removeEntity in interface DatabaseEngine
    
    Parameters:
    name - The name of the entity to remove.
    
    Returns:
    The entity removed or null if there's no entity with the given name.
  - containsEntity
```
public boolean containsEntity(String name)
```
    Description copied from interface: DatabaseEngine
    
    Returns if the current engine contains the entity.
    
    Specified by:
    
    containsEntity in interface DatabaseEngine
    
    Parameters:
    name - The entity name.
    
    Returns:
    True if the engine has the entity, false otherwise.
  - dropEntity
```
public void dropEntity(String entity)
                throws DatabaseEngineException
```
    Drops an entity.
    
    Specified by:
    
    dropEntity in interface DatabaseEngine
    
    Parameters:
    entity - The entity name.
    
    Throws:
    
    DatabaseEngineException
  - dropEntity
```
public void dropEntity(DbEntity entity)
                throws DatabaseEngineException
```
    Drops everything that belongs to the entity.
    
    Parameters:
    entity - The entity.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong while dropping the structures.
  - persist
```
public abstract Long persist(String name,
           EntityEntry entry)
                      throws DatabaseEngineException
```
    Persists a given entry. Persisting a query implies executing the statement.
    
    If you are inside of an explicit transaction, changes will only be visible upon explicit commit, otherwise a commit will immediately take place.
    
    Specified by:
    
    persist in interface DatabaseEngine
    
    Parameters:
    name - The entity name.
    entry - The entry to persist.
    
    Returns:
    The ID of the auto generated value, null if there's no auto generated value.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong while persisting data.
  - persist
```
public abstract Long persist(String name,
           EntityEntry entry,
           boolean useAutoInc)
                      throws DatabaseEngineException
```
    Persists a given entry. Persisting a query implies executing the statement. If define useAutoInc as false, PDB will disable the auto increments for the current insert and advance the sequences if needed.
    
    If you are inside of an explicit transaction, changes will only be visible upon explicit commit, otherwise a commit will immediately take place.
    
    Specified by:
    
    persist in interface DatabaseEngine
    
    Parameters:
    name - The entity name.
    entry - The entry to persist.
    useAutoInc - Use or not the autoinc.
    
    Returns:
    The ID of the auto generated value, null if there's no auto generated value.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong while persisting data.
  - flush
```
public void flush()
           throws DatabaseEngineException
```
    Flushes the batches for all the registered entities.
    
    Specified by:
    
    flush in interface DatabaseEngine
    
    Throws:
    
    DatabaseEngineException - If something goes wrong while persisting data.
  - commit
```
public void commit()
            throws DatabaseEngineRuntimeException
```
    Commits the current transaction. You should only call this method if you've previously called beginTransaction().
    
    Specified by:
    
    commit in interface DatabaseEngine
    
    Throws:
    
    DatabaseEngineException - If something goes wrong while persisting data.
    
    DatabaseEngineRuntimeException
  - rollback
```
public void rollback()
              throws DatabaseEngineRuntimeException
```
    Rolls back a transaction. You should only call this method if you've previously called beginTransaction().
    
    Specified by:
    
    rollback in interface DatabaseEngine
    
    Throws:
    
    DatabaseEngineRuntimeException - If the rollback fails.
  - isTransactionActive
```
public boolean isTransactionActive()
                            throws DatabaseEngineRuntimeException
```
    Description copied from interface: DatabaseEngine
    
    Checks if a transaction is active.
    
    Specified by:
    
    isTransactionActive in interface DatabaseEngine
    
    Returns:
    True if the transaction is active.
    
    Throws:
    
    DatabaseEngineRuntimeException - If the access to the database fails.
  - executeUpdate
```
public int executeUpdate(String query)
                  throws DatabaseEngineException
```
    Executes a native query.
    
    Specified by:
    
    executeUpdate in interface DatabaseEngine
    
    Parameters:
    query - The query to execute.
    
    Returns:
    The number of rows updated.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong executing the native query.
  - executeUpdate
```
public int executeUpdate(Expression query)
                  throws DatabaseEngineException
```
    Executes the given update.
    
    Specified by:
    
    executeUpdate in interface DatabaseEngine
    
    Parameters:
    query - The update to execute.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong executing the update.
  - translate
```
public String translate(Expression query)
```
    Translates the given expression to the current dialect.
    
    Specified by:
    
    translate in interface DatabaseEngine
    
    Parameters:
    query - The query to translate.
    
    Returns:
    The translation result.
  - getDialect
```
public Dialect getDialect()
```
    Description copied from interface: DatabaseEngine
    
    Gets the dialect being used.
    
    Specified by:
    
    getDialect in interface DatabaseEngine
    
    Returns:
    The dialect being in use.
  - createBatch
```
public AbstractBatch createBatch(int batchSize,
                        long batchTimeout)
```
    Creates a new batch that periodically flushes a batch. A flush will also occur when the maximum number of statements in the batch is reached.
    Please be sure to call AbstractBatch.destroy() before closing the session with the database
    
    Specified by:
    
    createBatch in interface DatabaseEngine
    
    Parameters:
    batchSize - The batch size.
    batchTimeout - If inserts do not occur after the specified time, a flush will be performed.
    
    Returns:
    The batch.
  - createBatch
```
public AbstractBatch createBatch(int batchSize,
                        long batchTimeout,
                        String batchName)
```
    Description copied from interface: DatabaseEngine
    
    Creates a new batch that periodically flushes a batch. A flush will also occur when the maximum number of statements in the batch is reached.
    Please be sure to call AbstractBatch.destroy() before closing the session with the database.
    
    Specified by:
    
    createBatch in interface DatabaseEngine
    
    Parameters:
    batchSize - The batch size.
    batchTimeout - If inserts do not occur after the specified time, a flush will be performed.
    batchName - The batch name.
    
    Returns:
    The batch.
  - checkConnection
```
protected abstract boolean checkConnection(Connection conn)
```
    Checks if the connection is alive.
    
    Parameters:
    conn - The connection to test.
    
    Returns:
    True if the connection is valid, false otherwise.
  - checkConnection
```
public boolean checkConnection(boolean forceReconnect)
```
    Checks if the connection is alive.
    
    Specified by:
    
    checkConnection in interface DatabaseEngine
    
    Parameters:
    forceReconnect - True to force the connection in case of failure.
    
    Returns:
    True if the connection is valid, false otherwise.
  - checkConnection
```
public boolean checkConnection()
```
    Checks if the connection is alive.
    
    Specified by:
    
    checkConnection in interface DatabaseEngine
    
    Returns:
    True if the connection is valid, false otherwise.
  - addBatch
```
public void addBatch(String name,
            EntityEntry entry)
              throws DatabaseEngineException
```
    Add an entry to the batch.
    
    Specified by:
    
    addBatch in interface DatabaseEngine
    
    Parameters:
    name - The entity name.
    entry - The entry to persist.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong while persisting data.
  - entityToPreparedStatement
```
protected abstract int entityToPreparedStatement(DbEntity entity,
                            PreparedStatement ps,
                            EntityEntry entry,
                            boolean useAutoIncs)
                                          throws DatabaseEngineException
```
    Translates the given entry entity to the prepared statement.
    
    Parameters:
    entity - The entity.
    ps - The prepared statement.
    entry - The entry.
    
    Returns:
    The prepared statement filled in.
    
    Throws:
    
    DatabaseEngineException - if something occurs during the translation.
  - query
```
public List<Map<String,ResultColumn>> query(Expression query)
                                     throws DatabaseEngineException
```
    Executes the given query.
    
    Specified by:
    
    query in interface DatabaseEngine
    
    Parameters:
    query - The query to execute.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong executing the query.
  - query
```
public List<Map<String,ResultColumn>> query(String query)
                                     throws DatabaseEngineException
```
    Executes the given query.
    
    Specified by:
    
    query in interface DatabaseEngine
    
    Parameters:
    query - The query to execute.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong executing the query.
  - processResultIterator
```
protected List<Map<String,ResultColumn>> processResultIterator(ResultIterator it)
                                                        throws DatabaseEngineException
```
    Process a whole ResultIterator.
    
    Parameters:
    it - The iterator.
    
    Returns:
    A list of rows in the form of Map.
    
    Throws:
    
    DatabaseEngineException - If a database access error occurs.
  - iterator
```
public ResultIterator iterator(String query)
                        throws DatabaseEngineException
```
    Description copied from interface: DatabaseEngine
    
    Creates an iterator for the given SQL sentence.
    
    Specified by:
    
    iterator in interface DatabaseEngine
    
    Parameters:
    query - The query.
    
    Returns:
    An iterator for the results of the given SQL query.
    
    Throws:
    
    DatabaseEngineException - If a database access error occurs.
  - iterator
```
public ResultIterator iterator(Expression query)
                        throws DatabaseEngineException
```
    Description copied from interface: DatabaseEngine
    
    Creates an iterator for the given SQL expression.
    
    Specified by:
    
    iterator in interface DatabaseEngine
    
    Parameters:
    query - The expression that represents the query.
    
    Returns:
    An iterator for the results of the given SQL expression.
    
    Throws:
    
    DatabaseEngineException - If a database access error occurs.
  - createResultIterator
```
protected abstract ResultIterator createResultIterator(Statement statement,
                                  String sql)
                                                throws DatabaseEngineException
```
    Creates a specific ResultIterator given the engine implementation.
    
    Parameters:
    statement - The statement.
    sql - The SQL sentence.
    
    Returns:
    An iterator for the specific engine.
    
    Throws:
    
    DatabaseEngineException - If a database access error occurs.
  - createTable
```
protected abstract void createTable(DbEntity entity)
                             throws DatabaseEngineException
```
    Creates the table.
    
    Parameters:
    entity - The entity.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong while creating the table.
  - addPrimaryKey
```
protected abstract void addPrimaryKey(DbEntity entity)
                               throws DatabaseEngineException
```
    Add a primary key to the entity.
    
    Parameters:
    entity - The entity.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong while creating the table.
  - addIndexes
```
protected abstract void addIndexes(DbEntity entity)
                            throws DatabaseEngineException
```
    Add the desired indexes.
    
    Parameters:
    entity - The entity.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong while creating the table.
  - addSequences
```
protected abstract void addSequences(DbEntity entity)
                              throws DatabaseEngineException
```
    Adds the necessary sequences.
    
    Parameters:
    entity - The entity.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong while creating the table.
  - dropSequences
```
protected abstract void dropSequences(DbEntity entity)
                               throws DatabaseEngineException
```
    Drops the sequences of the entity.
    
    Parameters:
    entity - The entity.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong dropping the sequences.
  - dropTable
```
protected abstract void dropTable(DbEntity entity)
                           throws DatabaseEngineException
```
    Drops the table.
    
    Parameters:
    entity - The entity.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong dropping the sequences.
  - dropColumn
```
protected abstract void dropColumn(DbEntity entity,
              String... columns)
                            throws DatabaseEngineException
```
    Drops the column.
    
    Parameters:
    entity - The entity.
    columns - The column name to drop.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong dropping the sequences.
    Since:
    
    12.1.0
  - addColumn
```
protected abstract void addColumn(DbEntity entity,
             DbColumn... columns)
                           throws DatabaseEngineException
```
    Adds the column to an existent table.
    
    Parameters:
    entity - The entity that represents the table.
    columns - The db column to add.
    
    Throws:
    
    DatabaseEngineException
    Since:
    
    12.1.0
  - addFks
```
protected abstract void addFks(DbEntity entity)
                        throws DatabaseEngineException
```
    Adds the FKs.
    
    Parameters:
    entity - The entity.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong creating the FKs.
  - createPreparedStatementForInserts
```
protected abstract MappedEntity createPreparedStatementForInserts(DbEntity entity)
                                                           throws DatabaseEngineException
```
    Creates and gets the prepared statement that will be used for insertions.
    
    Parameters:
    entity - The entity.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong while creating the table.
  - translateType
```
protected abstract String translateType(DbColumn c)
                                 throws DatabaseEngineException
```
    Translates the type present in the given column.
    
    Parameters:
    c - The column.
    
    Returns:
    The translation.
    
    Throws:
    
    DatabaseEngineException - If the type cannot be found.
  - createResultIterator
```
protected abstract ResultIterator createResultIterator(PreparedStatement ps)
                                                throws DatabaseEngineException
```
    Creates a specific ResultIterator for the engine in place given given prepared statement.
    
    Parameters:
    ps - The prepared statement.
    
    Returns:
    The result iterator.
    
    Throws:
    
    DatabaseEngineException - If a database access error occurs.
  - dropFks
```
protected void dropFks(String table)
                throws DatabaseEngineException
```
    Drops this table foreign keys.
    
    Parameters:
    table - The table name.
    
    Throws:
    
    Exception
    
    DatabaseEngineException
  - getEntities
```
public Map<String,DbEntityType> getEntities()
                                     throws DatabaseEngineException
```
    Gets the database entities.
    
    Specified by:
    
    getEntities in interface DatabaseEngine
    
    Returns:
    The list of database entities and types (tables, views, procedures, and so on).
    
    Throws:
    
    DatabaseEngineException - If something occurs getting the existing tables.
  - executeUpdateSilently
```
protected void executeUpdateSilently(String statement)
```
    Executes the given statement.
    If the statement for some reason fails to execute, the error is logged but no exception is thrown.
    
    Parameters:
    statement - The statement.
  - getSchema
```
protected String getSchema()
```
    Gets the schema.
    
    Returns:
    The schema.
  - getMetadata
```
public Map<String,DbColumnType> getMetadata(String name)
                                     throws DatabaseEngineException
```
    Gets the table metadata.
    
    Specified by:
    
    getMetadata in interface DatabaseEngine
    
    Returns:
    A representation of the table columns and types.
    
    Throws:
    
    DatabaseEngineException - If something occurs getting the metadata.
  - getQueryMetadata
```
public Map<String,DbColumnType> getQueryMetadata(Expression query)
                                          throws DatabaseEngineException
```
    Gets the query metadata.
    
    Specified by:
    
    getQueryMetadata in interface DatabaseEngine
    
    Parameters:
    query - The query to retrieve the metadata from.
    
    Returns:
    A representation of the table columns and types.
    
    Throws:
    
    DatabaseEngineException - If something occurs getting the metadata.
  - getQueryMetadata
```
public Map<String,DbColumnType> getQueryMetadata(String query)
                                          throws DatabaseEngineException
```
    Gets the query metadata.
    
    Specified by:
    
    getQueryMetadata in interface DatabaseEngine
    
    Parameters:
    query - The query to retrieve the metadata from.
    
    Returns:
    A representation of the table columns and types.
    
    Throws:
    
    DatabaseEngineException - If something occurs getting the metadata.
  - toPdbType
```
protected DbColumnType toPdbType(int type)
```
    Maps the database type to DbColumnType. If there's no mapping a DbColumnType.UNMAPPED is returned.
    
    Parameters:
    type - The SQL type from Types.
    
    Returns:
    The DbColumnType.
  - duplicate
```
public DatabaseEngine duplicate(Properties mergeProperties,
                       boolean copyEntities)
                         throws DuplicateEngineException
```
    Duplicates a connection.
    
    Specified by:
    
    duplicate in interface DatabaseEngine
    
    Parameters:
    mergeProperties - Merge properties with the ones already existing.
    copyEntities - True to include the entities in the new connection, false otherwise.
    
    Returns:
    The new connection.
    
    Throws:
    
    DuplicateEngineException - If policy is set to other than 'create' or 'none' or duplication fails for some reason.
  - getProperties
```
public PdbProperties getProperties()
```
    Description copied from interface: DatabaseEngine
    
    Gets the properties in use.
    
    Specified by:
    
    getProperties in interface DatabaseEngine
    
    Returns:
    A clone of the properties in use.
  - createPreparedStatement
```
public void createPreparedStatement(String name,
                           Expression query)
                             throws NameAlreadyExistsException,
                                    DatabaseEngineException
```
    Description copied from interface: DatabaseEngine
    
    Creates a prepared statement.
    
    Specified by:
    
    createPreparedStatement in interface DatabaseEngine
    
    Parameters:
    name - The prepared statement name.
    query - The query.
    
    Throws:
    
    NameAlreadyExistsException - If the name already exists.
    
    DatabaseEngineException - If something goes wrong creating the statement.
  - createPreparedStatement
```
public void createPreparedStatement(String name,
                           String query)
                             throws NameAlreadyExistsException,
                                    DatabaseEngineException
```
    Description copied from interface: DatabaseEngine
    
    Creates a prepared statement.
    
    Specified by:
    
    createPreparedStatement in interface DatabaseEngine
    
    Parameters:
    name - The prepared statement name.
    query - The query.
    
    Throws:
    
    NameAlreadyExistsException - If the name already exists.
    
    DatabaseEngineException - If something goes wrong creating the statement.
  - createPreparedStatement
```
public void createPreparedStatement(String name,
                           Expression query,
                           int timeout)
                             throws NameAlreadyExistsException,
                                    DatabaseEngineException
```
    Description copied from interface: DatabaseEngine
    
    Creates a prepared statement.
    
    Specified by:
    
    createPreparedStatement in interface DatabaseEngine
    
    Parameters:
    name - The prepared statement name.
    query - The query.
    timeout - The timeout (in seconds) for the query to execute.
    
    Throws:
    
    NameAlreadyExistsException - If the name already exists.
    
    DatabaseEngineException - If something goes wrong creating the statement.
  - createPreparedStatement
```
public void createPreparedStatement(String name,
                           String query,
                           int timeout)
                             throws NameAlreadyExistsException,
                                    DatabaseEngineException
```
    Description copied from interface: DatabaseEngine
    
    Creates a prepared statement.
    
    Specified by:
    
    createPreparedStatement in interface DatabaseEngine
    
    Parameters:
    name - The prepared statement name.
    query - The query.
    timeout - The timeout (in seconds) for the query to execute.
    
    Throws:
    
    NameAlreadyExistsException - If the name already exists.
    
    DatabaseEngineException - If something goes wrong creating the statement.
  - removePreparedStatement
```
public void removePreparedStatement(String name)
```
    Description copied from interface: DatabaseEngine
    
    Removes the given prepared statement.
    
    Specified by:
    
    removePreparedStatement in interface DatabaseEngine
    
    Parameters:
    name - The prepared statement name.
  - getPSResultSet
```
public List<Map<String,ResultColumn>> getPSResultSet(String name)
                                              throws DatabaseEngineException
```
    Gets the result set of the specified prepared statement.
    
    Specified by:
    
    getPSResultSet in interface DatabaseEngine
    
    Parameters:
    name - The prepared statement name.
    
    Returns:
    The result.
    
    Throws:
    
    DatabaseEngineException - If something occurs getting the result.
  - getPSIterator
```
public ResultIterator getPSIterator(String name)
                             throws DatabaseEngineException
```
    Description copied from interface: DatabaseEngine
    
    Creates an iterator for the PreparedStatement bound to the given name.
    
    Specified by:
    
    getPSIterator in interface DatabaseEngine
    
    Parameters:
    name - The name of the prepared statement.
    
    Returns:
    An iterator for the results of the prepared statement of the given name.
    
    Throws:
    
    DatabaseEngineException
  - setParameters
```
public void setParameters(String name,
                 Object... params)
                   throws DatabaseEngineException,
                          ConnectionResetException
```
    Description copied from interface: DatabaseEngine
    
    Sets the parameters on the specified prepared statement.
    
    Specified by:
    
    setParameters in interface DatabaseEngine
    
    Parameters:
    name - The prepared statement name.
    params - The parameters to set.
    
    Throws:
    
    DatabaseEngineException - If something occurs setting the parameters.
    
    ConnectionResetException - If the connection was reset while trying to set parameters.
  - setParameter
```
public void setParameter(String name,
                int index,
                Object param)
                  throws DatabaseEngineException,
                         ConnectionResetException
```
    Description copied from interface: DatabaseEngine
    
    Sets the parameter on the specified index.
    
    Specified by:
    
    setParameter in interface DatabaseEngine
    
    Parameters:
    name - The prepared statement name.
    index - The index to set.
    param - The parameter to set.
    
    Throws:
    
    DatabaseEngineException - If something occurs setting the parameters.
    
    ConnectionResetException - If the connection was reset while trying to set the parameter.
  - executePS
```
public void executePS(String name)
               throws DatabaseEngineException,
                      ConnectionResetException
```
    Executes the specified prepared statement.
    
    Specified by:
    
    executePS in interface DatabaseEngine
    
    Parameters:
    name - The prepared statement name.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong while executing.
    
    ConnectionResetException - If the connection is down and reestablishment occurs. If this happens, the user must reset the parameters and re-execute the query.
  - clearParameters
```
public void clearParameters(String name)
                     throws DatabaseEngineException,
                            ConnectionResetException
```
    Clears the prepared statement parameters.
    
    Specified by:
    
    clearParameters in interface DatabaseEngine
    
    Parameters:
    name - The prepared statement name.
    
    Throws:
    
    DatabaseEngineException - If something occurs while clearing the parameters.
    
    ConnectionResetException - If the connection was reset.
  - preparedStatementExists
```
public boolean preparedStatementExists(String name)
```
    Checks if there's a prepared statement with the given name.
    
    Specified by:
    
    preparedStatementExists in interface DatabaseEngine
    
    Parameters:
    name - The name to test.
    
    Returns:
    True if it exists, false otherwise.
  - executePSUpdate
```
public Integer executePSUpdate(String name)
                        throws DatabaseEngineException,
                               ConnectionResetException
```
    Executes update on the specified prepared statement.
    
    Specified by:
    
    executePSUpdate in interface DatabaseEngine
    
    Parameters:
    name - The prepared statement name.
    
    Throws:
    
    DatabaseEngineException - If the prepared statement does not exist or something goes wrong while executing.
    
    ConnectionResetException - If the connection is down and reestablishment occurs. If this happens, the user must reset the parameters and re-execute the query.
  - commentCharacter
```
public String commentCharacter()
```
    Specified by:
    
    commentCharacter in interface DatabaseEngine
    
    Returns:
    The comment character of this engine implementation.
  - escapeCharacter
```
public String escapeCharacter()
```
    Specified by:
    
    escapeCharacter in interface DatabaseEngine
    
    Returns:
    The escape character of this engine implementation.
  - setExceptionHandler
```
public void setExceptionHandler(ExceptionHandler eh)
```
    Description copied from interface: DatabaseEngine
    
    Sets the given exception handler in the engine.
    
    Specified by:
    
    setExceptionHandler in interface DatabaseEngine
    
    Parameters:
    eh - The reference for exception callbacks.
  - handleOperation
```
protected void handleOperation(OperationFault op,
                   Exception e)
                        throws DatabaseEngineException
```
    Controls if the given faulty operation must be silenced or not. The decision can be controlled by an external party using for that matter the setExceptionHandler(ExceptionHandler) method to provide a specific implementation.
    
    Parameters:
    op - The operation that originated the exception.
    e - The exception.
    
    Throws:
    
    DatabaseEngineException - If the faulty operation must stop the execution.
  - objectToArray
```
protected final byte[] objectToArray(Object val)
                              throws IOException
```
    Converts an object to byte array.
    
    Parameters:
    val - The object to convert.
    
    Returns:
    The byte array representation of the object.
    
    Throws:
    
    IOException - If the buffer is not enough to make the conversion.
  - hasIdentityColumn
```
public boolean hasIdentityColumn(DbEntity entity)
```
    Check if the entity has an identity column.
    
    Parameters:
    entity - The entity to check.
    
    Returns:
    True if the entity has an identity column and false otherwise.
  - inject
```
protected void inject(Expression... objs)
```

Class AbstractDatabaseEngine

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

injector

translator

conn

dev

logger

notificationLogger

entities

stmts

properties

diaclect

eh

Constructor Detail

AbstractDatabaseEngine

Method Detail

connect

getFinalJdbcConnection

setTransactionIsolation

getTranslatorClass

getConnection

close

beginTransaction

addEntity

updateEntity

removeEntity

containsEntity

dropEntity

dropEntity

persist

persist

flush

commit

rollback

isTransactionActive

executeUpdate

executeUpdate

translate

getDialect

createBatch

createBatch

checkConnection

checkConnection

checkConnection

addBatch

entityToPreparedStatement

query

query

processResultIterator

iterator

iterator

createResultIterator

createTable

addPrimaryKey

addIndexes

addSequences

dropSequences

dropTable

dropColumn

addColumn

addFks

createPreparedStatementForInserts

translateType

createResultIterator

dropFks

getEntities

executeUpdateSilently

getSchema

getMetadata

getQueryMetadata

getQueryMetadata

toPdbType

duplicate

getProperties

createPreparedStatement

createPreparedStatement