AbstractDatabaseEngine (pdb 2.8.18 API)

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

All Implemented Interfaces:

DatabaseEngine, AutoCloseable

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 String`	`currentSchema` The current schema that's being used by the engine.
`static QueryExceptionHandler`	`DEFAULT_QUERY_EXCEPTION_HANDLER` The default instance of `QueryExceptionHandler` to be used in disambiguating SQL exceptions.
`protected static org.slf4j.Marker`	`dev` The dev Marker.
`protected Dialect`	`dialect` 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 ExecutorService`	`socketTimeoutExecutor` An `ExecutorService` to be used by the DB drivers to break a connection if it has been blocked for longer than the specified socket timeout
`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

All Methods Instance Methods Abstract Methods Concrete 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 void`	`addFks(DbEntity entity)` Adds all foreign keys defined in the entity to the table in the database.
`protected void`	`addFks(DbEntity entity, Set<DbFk> fks)` Adds foreign key constraints to the table in the database that the provided entity represents.
`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 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.
`<PB extends PdbBatch> PB`	`createBatch(BatchConfig<PB> batchConfig)` Creates a new `PdbBatch` to which entries can be added; it then flushes those entries to the database, periodically on a set timeout, or when a maximum number of entries has been reached.
`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.
`AbstractBatch`	`createBatch(int batchSize, long batchTimeout, String batchName, BatchListener batchListener)` Creates a new batch that periodically flushes a batch.
`AbstractBatch`	`createBatch(int batchSize, long batchTimeout, String batchName, BatchListener batchListener, org.slf4j.Logger confidentialLogger)` Creates a new batch that periodically flushes a batch.
`AbstractBatch`	`createBatch(int batchSize, long batchTimeout, String batchName, FailureListener failureListener)` 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 a prepared statement.
`protected abstract ResultIterator`	`createResultIterator(Statement statement, String sql)` Creates a specific `ResultIterator` given the engine implementation.
`protected Statement`	`createSelectStatement(int readTimeout)` Creates a `Statement` that will be used for selects, i.e., may have an associated read timeout.
`protected abstract void`	`createTable(DbEntity entity)` Creates the table.
`protected abstract long`	`doPersist(PreparedStatement ps, MappedEntity me, boolean useAutoInc, int lastBindPosition)` DB engine specific auxiliary method for `persist(String, EntityEntry, boolean)` to effectively perform the persist action.
`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 String`	`dropFkQuery(String table, String fkName)` Gets the query to drop a foreign key.
`protected void`	`dropFks(String table)` Drops all foreign keys from the table.
`protected void`	`dropFks(String table, Set<String> fks)` Drops foreign keys from a table.
`protected abstract void`	`dropSequences(DbEntity entity)` Drops the sequences of the entity.
`protected abstract void`	`dropTable(DbEntity entity)` Drops the table.
`void`	`dropView(String view)` Drops a view.
`DatabaseEngine`	`duplicate(Properties mergeProperties, boolean copyEntities)` Duplicates a connection.
`protected int`	`entityToPreparedStatement(DbEntity entity, PreparedStatement ps, EntityEntry entry, boolean useAutoInc)` Translates the given entry entity to the prepared statement.
`protected int`	`entityToPreparedStatementForBatch(DbEntity entity, PreparedStatement ps, EntityEntry entry, boolean useAutoInc)` Translates the given entry entity to the prepared statement when used in the context of batch updates.
`protected int`	`entityToPreparedStatementInternal(DbEntity entity, PreparedStatement ps, EntityEntry entry, boolean useAutoInc, boolean fromBatch)` 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.
`protected Properties`	`getDBProperties()` Get the properties to be passed to the database connection that will be created.
`Dialect`	`getDialect()` Gets the dialect being used.
`Map<String,DbEntityType>`	`getEntities()` Gets the database entities for the current schema.
`Map<String,DbEntityType>`	`getEntities(String schemaPattern)` Gets the database entities for the specified schema.
`protected String`	`getFinalJdbcConnection(String jdbc)` Gets the final JDBC connection.
`protected ResultSet`	`getImportedKeys(String entityName)` Gets a description of the columns that are referenced by the given table's foreign key columns.
`Map<String,DbColumnType>`	`getMetadata(String tableNamePattern)` Gets the table metadata (table must be in the current schema).
`Map<String,DbColumnType>`	`getMetadata(String schemaPattern, String tableNamePattern)` Gets the table metadata (table must be in the current schema).
`protected PreparedStatement`	`getPreparedStatementForPersist(boolean useAutoInc, MappedEntity mappedEntity)` Gets the `PreparedStatement` to use in a persist operation, depending on whether autoInc is to be used or not.
`protected String`	`getPrivateKey()` Reads the private key from the secret location.
`PdbProperties`	`getProperties()` Gets the properties in use.
`ResultIterator`	`getPSIterator(String name)` Creates an iterator for the `PreparedStatement` bound to the given name.
`ResultIterator`	`getPSIterator(String name, int fetchSize)` 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.
`protected QueryExceptionHandler`	`getQueryExceptionHandler()` Gets the instance of `QueryExceptionHandler` to be used in disambiguating SQL exceptions.
`Map<String,DbColumnType>`	`getQueryMetadata(Expression query)` Gets the query metadata.
`Map<String,DbColumnType>`	`getQueryMetadata(String query)` Gets the query metadata.
`String`	`getSchema()` Gets the schema being used in the current `connection`.
`abstract Class<? extends AbstractTranslator>`	`getTranslatorClass()` Gets the class that translates SQL bound to this engine.
`protected void`	`handleOperation(OperationFault opFault, Exception exception)` 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(Expression query, int fetchSize)` Creates an iterator for the given SQL expression.
`ResultIterator`	`iterator(Expression query, int fetchSize, int readTimeoutOverride)` Creates an iterator for the given SQL expression overriding the configured query timeout (see `PdbProperties.getSelectQueryTimeout()`) if the underlying engine supports query timeouts.
`ResultIterator`	`iterator(String query)` Creates an iterator for the given SQL sentence.
`ResultIterator`	`iterator(String query, int fetchSize)` Creates an iterator for the given SQL sentence.
`ResultIterator`	`iterator(String query, int fetchSize, int readTimeoutOverride)` Creates an iterator for the given SQL sentence overriding the configured query timeout (see `PdbProperties.getSelectQueryTimeout()`) if the underlying engine supports query timeouts.
`void`	`loadEntity(DbEntity entity)` Loads an entity into the engine.
`protected byte[]`	`objectToArray(Object val)` Converts an object to byte array.
`protected void`	`onConnectionCreated()` To be called when the connection to the database is successfully created.
`Long`	`persist(String name, EntityEntry entry)` Persists a given entry.
`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(Expression query, int readTimeoutOverride)` Executes the given query overriding the configured query timeout (see `PdbProperties.getSelectQueryTimeout()`) if the underlying engine supports query timeouts.
`List<Map<String,ResultColumn>>`	`query(String query)` Executes the given query.
`List<Map<String,ResultColumn>>`	`query(String query, int readTimeoutOverride)` Executes the given native query overriding the configured query timeout (see `PdbProperties.getSelectQueryTimeout()` if the underlying engine supports query timeouts.
`protected void`	`reconnectExceptionally(String message)` Verifies if a connection to the database is available, if not, an attempts to reestablished it are made by the `getConnection()`.
`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`	`setParameter(String name, int index, Object param, DbColumnType paramType)` Sets the parameter on the specified index given its type.
`void`	`setParameters(String name, Object... params)` Sets the parameters on the specified prepared statement.
`protected void`	`setParameterValues(PreparedStatement ps, int index, Object param)` Sets the value of a parameter in `index` to the value provided in `param`.
`protected void`	`setPreparedStatementValue(PreparedStatement ps, int index, DbColumn dbColumn, Object value, boolean fromBatch)` Sets a value in the prepared statement.
`protected void`	`setSchema(String schema)` Sets the schema for the current `connection`.
`protected void`	`setTransactionIsolation()` Sets the transaction isolation level.
`protected DbColumnType`	`toPdbType(int type, String typeName)` Maps the database type to `DbColumnType`.
`String`	`translate(Expression query)` Translates the given expression to the current dialect.
`protected String`	`translateType(DbColumn column)` 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

Methods inherited from interface com.feedzai.commons.sql.abstraction.engine.DatabaseEngine
isStringAggDistinctCapable

- 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 final org.slf4j.Logger logger
```
    The logger that will be used.
  - notificationLogger
```
protected final 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.
  - currentSchema
```
protected String currentSchema
```
    The current schema that's being used by the engine.
    
    Since:
    
    2.1.13
  - properties
```
protected final PdbProperties properties
```
    The configuration.
  - dialect
```
protected final Dialect dialect
```
    The dialect.
  - eh
```
protected ExceptionHandler eh
```
    The exception handler to control the flow when defining new entities.
  - socketTimeoutExecutor
```
protected final ExecutorService socketTimeoutExecutor
```
    An ExecutorService to be used by the DB drivers to break a connection if it has been blocked for longer than the specified socket timeout
  - DEFAULT_QUERY_EXCEPTION_HANDLER
```
public static final QueryExceptionHandler DEFAULT_QUERY_EXCEPTION_HANDLER
```
    The default instance of QueryExceptionHandler to be used in disambiguating SQL exceptions.
    
    Since:
    
    2.5.1
- 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
  - getPrivateKey
```
protected String getPrivateKey()
                        throws Exception
```
    Reads the private key from the secret location.
    
    Returns:
    
    A string with the private key.
    
    Throws:
    
    Exception - If something occurs while reading.
  - getDBProperties
```
protected Properties getDBProperties()
```
    Get the properties to be passed to the database connection that will be created. Since these properties are specific to the database engine, it is up to the AbstractDatabaseEngine implementation to specify them. This is used, for instance, to set the database connection timeout.
    
    Returns:
    
    the properties of the connection to the database.
  - 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.
  - onConnectionCreated
```
protected void onConnectionCreated()
                            throws DatabaseEngineException
```
    To be called when the connection to the database is successfully created.
    
    Throws:
    
    DatabaseEngineException - If something wrong occurs while interacting with the database.
    
    Since:
    
    2.8.10
  - 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
    
    Specified by:
    
    close in interface AutoCloseable
  - 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:
    
    DatabaseEngineRuntimeException - If something goes wrong while beginning transaction.
  - 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.
  - loadEntity
```
public void loadEntity(DbEntity entity)
                throws DatabaseEngineException
```
    Description copied from interface: DatabaseEngine
    
    Loads an entity into the engine.
    No DDL commands will be executed, only prepared statements will be created in order to persist data into the entities.
    
    Specified by:
    
    loadEntity in interface DatabaseEngine
    
    Parameters:
    
    entity - The entity to load into the connection.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong while loading the entity.
  - 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(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 - If something goes wrong while updating the entity.
    
    Since:
    
    2.0.0
  - getImportedKeys
```
protected ResultSet getImportedKeys(String entityName)
                             throws DatabaseEngineException,
                                    SQLException
```
    Gets a description of the columns that are referenced by the given table's foreign key columns.
    
    Parameters:
    
    entityName - The entity name.
    
    Returns:
    
    A ResultSet containing information about columns referenced by a foreign key.
    
    Throws:
    
    DatabaseEngineException - If it isn't possible to get current database metadata.
    
    SQLException - If a database access error occurs when getting key information.
  - 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 - If something goes wrong while dropping the entity.
  - dropEntity
```
public void dropEntity(DbEntity entity)
                throws DatabaseEngineException
```
    Drops everything that belongs to the entity.
    
    Specified by:
    
    dropEntity in interface DatabaseEngine
    
    Parameters:
    
    entity - The entity.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong while dropping the structures.
  - dropView
```
public void dropView(String view)
              throws DatabaseEngineException
```
    Description copied from interface: DatabaseEngine
    
    Drops a view.
    
    Specified by:
    
    dropView in interface DatabaseEngine
    
    Parameters:
    
    view - The view name.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong while dropping the view.
  - persist
```
public 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 final 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.
  - getPreparedStatementForPersist
```
protected PreparedStatement getPreparedStatementForPersist(boolean useAutoInc,
                                                           MappedEntity mappedEntity)
```
    Gets the PreparedStatement to use in a persist operation, depending on whether autoInc is to be used or not.
    
    Parameters:
    
    useAutoInc - Whether to use autoInc.
    
    mappedEntity - The mapped entity for which to get the prepared statement.
    
    Returns:
    
    the PreparedStatement.
    
    Since:
    
    2.5.1
  - doPersist
```
protected abstract long doPersist(PreparedStatement ps,
                                  MappedEntity me,
                                  boolean useAutoInc,
                                  int lastBindPosition)
                           throws Exception
```
    DB engine specific auxiliary method for persist(String, EntityEntry, boolean) to effectively perform the persist action.
    
    Parameters:
    
    ps - The PreparedStatement to use in the persist operation
    
    me - The mapped entity on which to persist.
    
    useAutoInc - Whether to use autoInc.
    
    lastBindPosition - The position (1-based) of the last bind parameter that was filled in the prepared statement.
    
    Returns:
    
    The ID of the auto generated value (0 if there's no auto generated value). If the table has more than 1 column with auto generated values, then it will return the first column found.
    
    Throws:
    
    Exception - if any problem occurs while persisting.
    
    Since:
    
    2.5.1
  - 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:
    
    DatabaseEngineRuntimeException - If something goes wrong while persisting data.
  - 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.
  - createSelectStatement
```
protected Statement createSelectStatement(int readTimeout)
                                   throws SQLException
```
    Creates a Statement that will be used for selects, i.e., may have an associated read timeout.
    
    Parameters:
    
    readTimeout - The timeout.
    
    Returns:
    
    The Statement
    
    Throws:
    
    SQLException - If there is an error creating the statement.
  - 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 <PB extends PdbBatch> PB createBatch(BatchConfig<PB> batchConfig)
```
    Description copied from interface: DatabaseEngine
    Creates a new PdbBatch to which entries can be added; it then flushes those entries to the database, periodically on a set timeout, or when a maximum number of entries has been reached.
    NOTES:
    1. All needed entities should be added before creating a batch, because some batch implementations (such as multithreaded) may create new connections, and they will only have visibility on the known entities before batch creation.
    2. AutoCloseable.close() should be called before closing the session with the database, to dispose of all the resources such as executors and extra connections.
    Specified by:
    
    createBatch in interface DatabaseEngine
    
    Parameters:
    
    batchConfig - The batch configuration.
    
    Returns:
    
    The batch.
  - 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.
  - createBatch
```
public AbstractBatch createBatch(int batchSize,
                                 long batchTimeout,
                                 String batchName,
                                 FailureListener failureListener)
```
    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.
    If desired you may provide an Optional FailureListener that will be invoked when the batch fails to persist data.
    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.
    
    failureListener - Failure listener to execute custom behavior when the batch fails to persist.
    
    Returns:
    
    The batch.
  - createBatch
```
public AbstractBatch createBatch(int batchSize,
                                 long batchTimeout,
                                 String batchName,
                                 @Nullable
                                 BatchListener batchListener)
```
    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.
    If desired you may provide a BatchListener that will be invoked when a batch operation fails or succeeds to persist data.
    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.
    
    batchListener - Batch listener to execute custom behavior when the batch fails or succeeds to persist.
    
    Returns:
    
    The batch.
  - createBatch
```
public AbstractBatch createBatch(int batchSize,
                                 long batchTimeout,
                                 String batchName,
                                 @Nullable
                                 BatchListener batchListener,
                                 @Nullable
                                 org.slf4j.Logger confidentialLogger)
```
    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.
    The default implementation of this method throws an UnsupportedOperationException for backward-compatibility reasons. If this method is supposed to be called, it must be explicitly overridden.
    
    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.
    
    batchListener - Batch listener to execute custom behavior when the batch fails or succeeds to persist.
    
    confidentialLogger - The confidential logger.
    
    Returns:
    
    The batch.
  - checkConnection
```
protected 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.
  - entityToPreparedStatementForBatch
```
protected int entityToPreparedStatementForBatch(DbEntity entity,
                                                PreparedStatement ps,
                                                EntityEntry entry,
                                                boolean useAutoInc)
                                         throws DatabaseEngineException
```
    Translates the given entry entity to the prepared statement when used in the context of batch updates.
    This can be overridden on engines where a distinct treatment is required for these situations, if it isn't possible to accommodate that behaviour by overriding setPreparedStatementValue(java.sql.PreparedStatement, int, com.feedzai.commons.sql.abstraction.ddl.DbColumn, java.lang.Object, boolean).
    
    Parameters:
    
    entity - The entity.
    
    ps - The prepared statement.
    
    entry - The entry.
    
    useAutoInc - Whether to use autoinc (auto incrementation of values for columns that support it).
    
    Returns:
    
    The position (1-based) of the last bind parameter that was filled in a prepared statement.
    
    Throws:
    
    DatabaseEngineException - if something occurs during the translation.
    
    Since:
    
    2.4.2
  - entityToPreparedStatement
```
protected int entityToPreparedStatement(DbEntity entity,
                                        PreparedStatement ps,
                                        EntityEntry entry,
                                        boolean useAutoInc)
                                 throws DatabaseEngineException
```
    Translates the given entry entity to the prepared statement.
    This can be overridden on engines where a distinct treatment is required for these situations, if it isn't possible to accommodate that behaviour by overriding setPreparedStatementValue(java.sql.PreparedStatement, int, com.feedzai.commons.sql.abstraction.ddl.DbColumn, java.lang.Object, boolean).
    
    Parameters:
    
    entity - The entity.
    
    ps - The prepared statement.
    
    entry - The entry.
    
    useAutoInc - Whether to use autoinc (auto incrementation of values for columns that support it).
    
    Returns:
    
    The position (1-based) of the last bind parameter that was filled in a prepared statement.
    
    Throws:
    
    DatabaseEngineException - If something wrong occurs during the translation.
  - entityToPreparedStatementInternal
```
protected int entityToPreparedStatementInternal(DbEntity entity,
                                                PreparedStatement ps,
                                                EntityEntry entry,
                                                boolean useAutoInc,
                                                boolean fromBatch)
                                         throws DatabaseEngineException
```
    Translates the given entry entity to the prepared statement.
    This can be overridden on engines where a distinct treatment is required for these situations, if it isn't possible to accommodate that behaviour by overriding setPreparedStatementValue(java.sql.PreparedStatement, int, com.feedzai.commons.sql.abstraction.ddl.DbColumn, java.lang.Object, boolean).
    
    Parameters:
    
    entity - The entity.
    
    ps - The prepared statement.
    
    entry - The entry.
    
    useAutoInc - Whether to use autoinc (auto incrementation of values for columns that support it).
    
    fromBatch - Whether this translation is to be done in the context of a batch update.
    
    Returns:
    
    The position (1-based) of the last bind parameter that was filled in a prepared statement.
    
    Throws:
    
    DatabaseEngineException - If something wrong occurs during the translation.
  - setPreparedStatementValue
```
protected void setPreparedStatementValue(PreparedStatement ps,
                                         int index,
                                         DbColumn dbColumn,
                                         Object value,
                                         boolean fromBatch)
                                  throws Exception
```
    Sets a value in the prepared statement.
    
    Parameters:
    
    ps - The prepared statement.
    
    index - The index of the value to set in the prepared statement.
    
    dbColumn - The DbColumn for which to set the value in the prepared statement.
    
    value - The value to set.
    
    fromBatch - Whether this translation is to be done in the context of a batch update.
    
    Throws:
    
    Exception - If something wrong occurs setting the value.
  - 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(Expression query,
                                            int readTimeoutOverride)
                                     throws DatabaseEngineException
```
    Description copied from interface: DatabaseEngine
    
    Executes the given query overriding the configured query timeout (see PdbProperties.getSelectQueryTimeout()) if the underlying engine supports query timeouts.
    
    Specified by:
    
    query in interface DatabaseEngine
    
    Parameters:
    
    query - The query to execute.
    
    readTimeoutOverride - The query timeout to use.
    
    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.
  - query
```
public List<Map<String,ResultColumn>> query(String query,
                                            int readTimeoutOverride)
                                     throws DatabaseEngineException
```
    Description copied from interface: DatabaseEngine
    
    Executes the given native query overriding the configured query timeout (see PdbProperties.getSelectQueryTimeout() if the underlying engine supports query timeouts.
    
    Specified by:
    
    query in interface DatabaseEngine
    
    Parameters:
    
    query - The query to execute.
    
    readTimeoutOverride - The query timeout to use.
    
    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.
  - iterator
```
public ResultIterator iterator(String query,
                               int fetchSize)
                        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.
    
    fetchSize - The number of rows to fetch each time.
    
    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,
                               int fetchSize)
                        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.
    
    fetchSize - The number of rows to fetch each time.
    
    Returns:
    
    An iterator for the results of the given SQL expression.
    
    Throws:
    
    DatabaseEngineException - If a database access error occurs.
  - iterator
```
public ResultIterator iterator(Expression query,
                               int fetchSize,
                               int readTimeoutOverride)
                        throws DatabaseEngineException
```
    Description copied from interface: DatabaseEngine
    
    Creates an iterator for the given SQL expression overriding the configured query timeout (see PdbProperties.getSelectQueryTimeout()) if the underlying engine supports query timeouts.
    
    Specified by:
    
    iterator in interface DatabaseEngine
    
    Parameters:
    
    query - The expression that represents the query.
    
    fetchSize - The number of rows to fetch each time.
    
    readTimeoutOverride - The query timeout to use.
    
    Returns:
    
    An iterator for the results of the given SQL expression.
    
    Throws:
    
    DatabaseEngineException - If a database access error occurs.
  - iterator
```
public ResultIterator iterator(String query,
                               int fetchSize,
                               int readTimeoutOverride)
                        throws DatabaseEngineException
```
    Description copied from interface: DatabaseEngine
    
    Creates an iterator for the given SQL sentence overriding the configured query timeout (see PdbProperties.getSelectQueryTimeout()) if the underlying engine supports query timeouts.
    
    Specified by:
    
    iterator in interface DatabaseEngine
    
    Parameters:
    
    query - The query.
    
    fetchSize - The number of rows to fetch each time.
    
    readTimeoutOverride - The query timeout to use.
    
    Returns:
    
    An iterator for the results of the given SQL query.
    
    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.
  - createResultIterator
```
protected abstract ResultIterator createResultIterator(PreparedStatement ps)
                                                throws DatabaseEngineException
```
    Creates a specific ResultIterator for the engine in place given a prepared statement.
    
    Parameters:
    
    ps - The prepared statement.
    
    Returns:
    
    The result iterator.
    
    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:
    
    2.0.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 - If something goes wrong adding columns.
    
    Since:
    
    2.0.0
  - addFks
```
protected void addFks(DbEntity entity)
               throws DatabaseEngineException
```
    Adds all foreign keys defined in the entity to the table in the database.
    
    Parameters:
    
    entity - The entity.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong creating the FKs.
  - addFks
```
protected void addFks(DbEntity entity,
                      Set<DbFk> fks)
               throws DatabaseEngineException
```
    Adds foreign key constraints to the table in the database that the provided entity represents.
    
    Parameters:
    
    entity - The entity.
    
    fks - The foreign keys to be added.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong creating the FKs.
    
    Since:
    
    2.8.1
  - 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 String translateType(DbColumn column)
                        throws DatabaseEngineException
```
    Translates the type present in the given column.
    
    Parameters:
    
    column - The column.
    
    Returns:
    
    The translation.
    
    Throws:
    
    DatabaseEngineException - If the type cannot be found.
  - dropFks
```
protected void dropFks(String table)
                throws DatabaseEngineException
```
    Drops all foreign keys from the table.
    
    Parameters:
    
    table - The table name.
    
    Throws:
    
    DatabaseEngineException - If something goes wrong dropping the FKs.
  - dropFkQuery
```
protected String dropFkQuery(String table,
                             String fkName)
```
    Gets the query to drop a foreign key.
    
    Parameters:
    
    table - The table name.
    
    fkName - The foreign key name.
    
    Returns:
    
    The query to drop the foreign key.
    
    Since:
    
    2.8.1
  - dropFks
```
protected void dropFks(String table,
                       Set<String> fks)
                throws DatabaseEngineException
```
    Drops foreign keys from a table.
    
    Parameters:
    
    table - The table.
    
    fks - The foreign key names to be dropped.
    
    Throws:
    
    DatabaseEngineException - If a foreign key can't be dropped.
    
    Since:
    
    2.8.1
  - getEntities
```
public Map<String,DbEntityType> getEntities()
                                     throws DatabaseEngineException
```
    Description copied from interface: DatabaseEngine
    
    Gets the database entities for the current schema.
    
    Specified by:
    
    getEntities in interface DatabaseEngine
    
    Returns:
    
    The list of database entities and types (tables, views, and so on).
    
    Throws:
    
    DatabaseEngineException - If something occurs getting the existing tables.
  - getEntities
```
public Map<String,DbEntityType> getEntities(String schemaPattern)
                                     throws DatabaseEngineException
```
    Description copied from interface: DatabaseEngine
    
    Gets the database entities for the specified schema.
    
    Specified by:
    
    getEntities in interface DatabaseEngine
    
    Parameters:
    
    schemaPattern - A schema name pattern; must match the schema name as it is stored in the database; "" retrieves those without a schema; null means that the schema name should not be used to narrow the search.
    
    Returns:
    
    The list of database entities and types (tables, views, 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
```
public String getSchema()
                 throws DatabaseEngineException
```
    Gets the schema being used in the current connection.
    
    Returns:
    
    The current schema name or null if there is none.
    
    Throws:
    
    DatabaseEngineException - If a database access error occurs or this method is called on a closed connection.
  - setSchema
```
protected void setSchema(String schema)
                  throws DatabaseEngineException
```
    Sets the schema for the current connection.
    
    Throws:
    
    DatabaseEngineException - If schema doesn't exist, a database access error occurs or this method is called on a closed connection.
    
    Since:
    
    2.1.13
  - getMetadata
```
public Map<String,DbColumnType> getMetadata(String tableNamePattern)
                                     throws DatabaseEngineException
```
    Description copied from interface: DatabaseEngine
    
    Gets the table metadata (table must be in the current schema).
    
    Specified by:
    
    getMetadata in interface DatabaseEngine
    
    Parameters:
    
    tableNamePattern - A table name pattern; must match the table name as it is stored in the database.
    
    Returns:
    
    A representation of the table columns and types.
    
    Throws:
    
    DatabaseEngineException - If something occurs getting the metadata.
  - getMetadata
```
public Map<String,DbColumnType> getMetadata(String schemaPattern,
                                            String tableNamePattern)
                                     throws DatabaseEngineException
```
    Description copied from interface: DatabaseEngine
    
    Gets the table metadata (table must be in the current schema).
    
    Specified by:
    
    getMetadata in interface DatabaseEngine
    
    Parameters:
    
    schemaPattern - A schema name pattern; must match the schema name as it is stored in the database; "" retrieves those without a schema; null means that the schema name should not be used to narrow the search.
    
    tableNamePattern - A table name pattern; must match the table name as it is stored in the database.
    
    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,
                                 String typeName)
```
    Maps the database type to DbColumnType. If there's no mapping a DbColumnType.UNMAPPED is returned.
    
    Parameters:
    
    type - The SQL type from Types.
    
    typeName - The native database type name. It provides additional information for derived classes to resolve types unmapped here.
    
    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,
                                                     ConnectionResetException
```
    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.
    
    ConnectionResetException - If the first Result Iterated fails to create.
  - getPSIterator
```
public ResultIterator getPSIterator(String name)
                             throws DatabaseEngineException,
                                    ConnectionResetException
```
    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 - If a database access error occurs.
    
    ConnectionResetException
  - getPSIterator
```
public ResultIterator getPSIterator(String name,
                                    int fetchSize)
                             throws DatabaseEngineException,
                                    ConnectionResetException
```
    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.
    
    fetchSize - The number of rows to fetch each time.
    
    Returns:
    
    An iterator for the results of the prepared statement of the given name.
    
    Throws:
    
    DatabaseEngineException - If a database access error occurs.
    
    ConnectionResetException
  - 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.
  - setParameter
```
public void setParameter(String name,
                         int index,
                         Object param,
                         DbColumnType paramType)
                  throws DatabaseEngineException,
                         ConnectionResetException
```
    Description copied from interface: DatabaseEngine
    
    Sets the parameter on the specified index given its type. This is for situations where the java type of the parameter alone is not enough to determine the corresponding database type; for example, Strings can be used to represent both actual Strings and Json values, so if we have an update statement that updates a json column we need to specify that the bind parameter is of type json.
    
    Specified by:
    
    setParameter in interface DatabaseEngine
    
    Parameters:
    
    name - The prepared statement name.
    
    index - The index to set.
    
    param - The parameter to set.
    
    paramType - The type of the parameter being 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 opFault,
                               Exception exception)
                        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:
    
    opFault - The operation that originated the exception.
    
    exception - 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)
```
  - setParameterValues
```
protected void setParameterValues(PreparedStatement ps,
                                  int index,
                                  Object param)
                           throws SQLException
```
    Sets the value of a parameter in index to the value provided in param.
    
    Parameters:
    
    ps - The PreparedStatement to insert the association between index and the param.
    
    index - The index to set the value to.
    
    param - The value to be set at the provided index.
    
    Throws:
    
    SQLException - If something goes wrong accessing the database.
  - getQueryExceptionHandler
```
protected QueryExceptionHandler getQueryExceptionHandler()
```
    Gets the instance of QueryExceptionHandler to be used in disambiguating SQL exceptions.
    
    Returns:
    
    the QueryExceptionHandler.
    
    Since:
    
    2.5.1
  - reconnectExceptionally
```
protected void reconnectExceptionally(String message)
                               throws DatabaseEngineException
```
    Verifies if a connection to the database is available, if not, an attempts to reestablished it are made by the getConnection().
    
    Parameters:
    
    message - The exception message.
    
    Throws:
    
    DatabaseEngineException - if an error occurs while reestablishing the connection.
    
    Since:
    
    2.7.0

Class AbstractDatabaseEngine

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.feedzai.commons.sql.abstraction.engine.DatabaseEngine

Field Detail

injector

translator

conn

dev

logger

notificationLogger

entities

stmts

currentSchema

properties

dialect

eh

socketTimeoutExecutor

DEFAULT_QUERY_EXCEPTION_HANDLER

Constructor Detail

AbstractDatabaseEngine

Method Detail

getPrivateKey

getDBProperties

connect

onConnectionCreated

getFinalJdbcConnection

setTransactionIsolation

getTranslatorClass

getConnection

close

beginTransaction

addEntity

loadEntity

updateEntity

getImportedKeys

removeEntity

containsEntity

dropEntity

dropEntity

dropView

persist

persist

getPreparedStatementForPersist

doPersist

flush

commit

rollback

isTransactionActive

executeUpdate

createSelectStatement

executeUpdate

translate

getDialect

createBatch

createBatch

createBatch

createBatch

createBatch

createBatch

checkConnection

checkConnection

checkConnection

addBatch

entityToPreparedStatementForBatch

entityToPreparedStatement

entityToPreparedStatementInternal

setPreparedStatementValue

query

query

query

query

processResultIterator

iterator

iterator

iterator

iterator

iterator