HibernatePersistentObjectDAO (logicaldoc 6.8.3 API)

java.lang.Object
- com.logicaldoc.core.HibernatePersistentObjectDAO<T>

All Implemented Interfaces:

PersistentObjectDAO<T>

Direct Known Subclasses:

HibernateBookmarkDAO, HibernateContactDAO, HibernateDocumentDAO, HibernateDocumentLinkDAO, HibernateDocumentNoteDAO, HibernateDocumentTemplateDAO, HibernateDownloadTicketDAO, HibernateFeedMessageDAO, HibernateFolderDAO, HibernateFolderHistoryDAO, HibernateGenericDAO, HibernateGroupDAO, HibernateHistoryDAO, HibernateMenuDAO, HibernateMessageTemplateDAO, HibernateRatingDAO, HibernateSystemMessageDAO, HibernateUserDAO, HibernateUserDocDAO, HibernateUserHistoryDAO, HibernateVersionDAO
```
public abstract class HibernatePersistentObjectDAO<T extends PersistentObject>
extends Object
implements PersistentObjectDAO<T>
```
Hibernate implementation of PersistentObjectDAO

Since:

4.0

Author:

Marco Meschieri - Logical Objects

Field Summary

Fields
Modifier and Type Field and Description

protected Class<T> entityClass

protected org.slf4j.Logger log

protected org.hibernate.SessionFactory sessionFactory

Fields
Modifier and Type	Field and Description
`protected Class<T>`	`entityClass`
`protected org.slf4j.Logger`	`log`
`protected org.hibernate.SessionFactory`	`sessionFactory`

Constructor Summary

Constructors
Modifier Constructor and Description

protected HibernatePersistentObjectDAO(Class<T> entityClass)

Constructors
Modifier	Constructor and Description
`protected`	`HibernatePersistentObjectDAO(Class<T> entityClass)`

Method Summary

Methods
Modifier and Type	Method and Description
`int`	`bulkUpdate(String expression, Object[] values)` Executes a bulk update as specified by the given expression
`boolean`	`delete(long id)` This method deletes an entity.
`void`	`deleteAll(Collection<T> entities)` Deletes all entries form the database
`protected void`	`evict(Object entity)`
`List<T>`	`findAll()` Finds all entities in the database
`List<Long>`	`findAllIds()` Finds all entities ids
`T`	`findById(long id)` This method finds an entity by ID.
`List`	`findByQuery(String query, Object[] values, Integer max)` Find everything you want from the DB using the ORM query language
`List<T>`	`findByWhere(String where, Object[] values, String order, Integer max)` Finds all entities by the given expression.
`List<T>`	`findByWhere(String where, String order, Integer max)` Finds all entities by the given expression.
`List<Long>`	`findIdsByWhere(String where, Object[] values, String order, Integer max)` Finds all entities ids by the given expression.
`List<Long>`	`findIdsByWhere(String where, String order, Integer max)` Finds all entities ids by the given expression.
`protected void`	`flush()`
`protected Connection`	`getConnection()`
`protected org.hibernate.Session`	`getCurrentSession()`
`String`	`getDbms()` Get the DBMS currently connected( possible values are: mysql, hsqldb, oracle, mssql)
`org.hibernate.SessionFactory`	`getSessionFactory()`
`void`	`initialize(T entity)` Doesn't do anything by default
`protected boolean`	`isHsql()`
`protected boolean`	`isMySQL()`
`protected boolean`	`isOracle()`
`protected boolean`	`isSqlServer()`
`int`	`jdbcUpdate(String statement)` Executes the given SQL update statement
`int`	`jdbcUpdate(String statement, Object... args)` Issue a single SQL update operation (such as an insert, update or delete statement) via a prepared statement, binding the given arguments.
`protected Object`	`merge(Object entity)`
`protected org.hibernate.Query`	`prepareQuery(String expression, Object[] values, Integer max)` Utility method useful for preparing an Hibernate query
`List`	`query(String sql, Object[] args, org.springframework.jdbc.core.RowMapper rowMapper, Integer maxRows)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, mapping each row to a Java object via a RowMapper.
`int`	`queryForInt(String sql)` Execute a query that results in an int value, given static SQL.
`List`	`queryForList(String sql, Class elementType)` Execute a query for a result list, given static SQL.
`List`	`queryForList(String sql, Object[] args, Class elementType, Integer maxRows)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result list.
`long`	`queryForLong(String sql)` Execute a query that results in an long value, given static SQL.
`org.springframework.jdbc.support.rowset.SqlRowSet`	`queryForRowSet(String sql, Object[] args, Integer maxRows)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, returns a navigable RowSet
`protected void`	`refresh(Object entity)`
`protected void`	`saveOrUpdate(Object entity)`
`void`	`setSessionFactory(org.hibernate.SessionFactory sessionFactory)`
`boolean`	`store(T entity)` This method persists the entity object.

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

- Field Detail
  - log
```
protected org.slf4j.Logger log
```
  - entityClass
```
protected Class<T extends PersistentObject> entityClass
```
  - sessionFactory
```
protected org.hibernate.SessionFactory sessionFactory
```
- Constructor Detail
  - HibernatePersistentObjectDAO
```
protected HibernatePersistentObjectDAO(Class<T> entityClass)
```
- Method Detail
  - setSessionFactory
```
public void setSessionFactory(org.hibernate.SessionFactory sessionFactory)
```
  - delete
```
public boolean delete(long id)
```
    Description copied from interface: PersistentObjectDAO
    
    This method deletes an entity.
    
    Specified by:
    
    delete in interface PersistentObjectDAO<T extends PersistentObject>
    
    Parameters:
    id - ID of the entity which should be deleted.
  - findAll
```
public List<T> findAll()
```
    Description copied from interface: PersistentObjectDAO
    
    Finds all entities in the database
    
    Specified by:
    
    findAll in interface PersistentObjectDAO<T extends PersistentObject>
    
    Returns:
    The list of all entities
  - findAllIds
```
public List<Long> findAllIds()
```
    Description copied from interface: PersistentObjectDAO
    
    Finds all entities ids
    
    Specified by:
    
    findAllIds in interface PersistentObjectDAO<T extends PersistentObject>
    
    Returns:
    The list of all entities ids
  - findById
```
public T findById(long id)
```
    Description copied from interface: PersistentObjectDAO
    
    This method finds an entity by ID.
    
    Specified by:
    
    findById in interface PersistentObjectDAO<T extends PersistentObject>
    
    Returns:
    Entity with given ID.
  - findByWhere
```
public List<T> findByWhere(String where,
                  String order,
                  Integer max)
```
    Description copied from interface: PersistentObjectDAO
    
    Finds all entities by the given expression. Use _entity alias to reference attributes in the where expression.
    
    Specified by:
    
    findByWhere in interface PersistentObjectDAO<T extends PersistentObject>
    
    Parameters:
    where - The where clause expression
    order - The order clause expression
    max - Maximum results number (optional)
    
    Returns:
    The list of marching entities
  - findByWhere
```
public List<T> findByWhere(String where,
                  Object[] values,
                  String order,
                  Integer max)
```
    Description copied from interface: PersistentObjectDAO
    
    Finds all entities by the given expression. Use _entity alias to reference attributes in the where expression.
    
    Specified by:
    
    findByWhere in interface PersistentObjectDAO<T extends PersistentObject>
    
    Parameters:
    where - The where clause expression (for positional parameters, please use JPA-style: ?1, ?2 ...)
    values - Parameters used in the where expression
    order - The order clause expression
    max - Maximum results number (optional)
    
    Returns:
    The list of marching entities
  - findByQuery
```
public List findByQuery(String query,
               Object[] values,
               Integer max)
```
    Description copied from interface: PersistentObjectDAO
    
    Find everything you want from the DB using the ORM query language
    
    Specified by:
    
    findByQuery in interface PersistentObjectDAO<T extends PersistentObject>
    
    Parameters:
    query - The query to execute (for positional parameters, please use JPA-style: ?1, ?2 ...)
    values - Array of paramaters
    max - Maximum results number (optional)
    
    Returns:
    Query result
  - findIdsByWhere
```
public List<Long> findIdsByWhere(String where,
                        String order,
                        Integer max)
```
    Description copied from interface: PersistentObjectDAO
    
    Finds all entities ids by the given expression. Use _entity alias to reference attributes in the where expression.
    
    Specified by:
    
    findIdsByWhere in interface PersistentObjectDAO<T extends PersistentObject>
    
    Parameters:
    where - The where clause expression
    order - The order clause expression
    max - Maximum results number (optional)
    
    Returns:
    The list of marching entities ids
  - findIdsByWhere
```
public List<Long> findIdsByWhere(String where,
                        Object[] values,
                        String order,
                        Integer max)
```
    Description copied from interface: PersistentObjectDAO
    
    Finds all entities ids by the given expression. Use _entity alias to reference attributes in the where expression.
    
    Specified by:
    
    findIdsByWhere in interface PersistentObjectDAO<T extends PersistentObject>
    
    Parameters:
    where - The where clause expression (for positional parameters, please use JPA-style: ?1, ?2 ...)
    values - Parameters used in the where expression
    order - The order clause expression
    max - Maximum results number (optional)
    
    Returns:
    The list of marching entities ids
  - store
```
public boolean store(T entity)
```
    Description copied from interface: PersistentObjectDAO
    
    This method persists the entity object.
    
    Specified by:
    
    store in interface PersistentObjectDAO<T extends PersistentObject>
    
    Parameters:
    entity - entity to be stored.
    
    Returns:
    True if successfully stored in a database.
  - saveOrUpdate
```
protected void saveOrUpdate(Object entity)
```
  - flush
```
protected void flush()
```
  - refresh
```
protected void refresh(Object entity)
```
  - merge
```
protected Object merge(Object entity)
```
  - evict
```
protected void evict(Object entity)
```
  - prepareQuery
```
protected org.hibernate.Query prepareQuery(String expression,
                               Object[] values,
                               Integer max)
```
    Utility method useful for preparing an Hibernate query
    
    Parameters:
    expression - The expression for the query
    values - The parameters values to be used (optional, if the query is parametric)
    max - Optional maximum number of wanted results
    
    Returns:
    The Hibernate query
  - initialize
```
public void initialize(T entity)
```
    Doesn't do anything by default
    
    Specified by:
    
    initialize in interface PersistentObjectDAO<T extends PersistentObject>
    
    Parameters:
    entity - The entity to be initialised
  - getCurrentSession
```
protected org.hibernate.Session getCurrentSession()
```
  - query
```
public List query(String sql,
         Object[] args,
         org.springframework.jdbc.core.RowMapper rowMapper,
         Integer maxRows)
```
    Description copied from interface: PersistentObjectDAO
    
    Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, mapping each row to a Java object via a RowMapper.
    
    Specified by:
    
    query in interface PersistentObjectDAO<T extends PersistentObject>
    
    Parameters:
    sql - SQL query to execute
    args - arguments to bind to the query (leaving it to the PreparedStatement to guess the corresponding SQL type); may also contain SqlParameterValue objects which indicate not only the argument value but also the SQL type and optionally the scale
    rowMapper - object that will map one object per row
    maxRows - the new max rows limit; null means there is no limit
    
    Returns:
    the result List, containing mapped objects
  - queryForList
```
public List queryForList(String sql,
                Object[] args,
                Class elementType,
                Integer maxRows)
```
    Description copied from interface: PersistentObjectDAO
    
    Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result list. The results will be mapped to a List (one entry for each row) of result objects, each of them matching the specified element type.
    
    Specified by:
    
    queryForList in interface PersistentObjectDAO<T extends PersistentObject>
    
    Parameters:
    sql - SQL query to execute
    args - arguments to bind to the query (leaving it to the PreparedStatement to guess the corresponding SQL type); may also contain SqlParameterValue objects which indicate not only the argument value but also the SQL type and optionally the scale
    elementType - the required type of element in the result list (for example, Integer.class)
    
    Returns:
    a List of objects that match the specified element type
  - queryForRowSet
```
public org.springframework.jdbc.support.rowset.SqlRowSet queryForRowSet(String sql,
                                                               Object[] args,
                                                               Integer maxRows)
```
    Description copied from interface: PersistentObjectDAO
    
    Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, returns a navigable RowSet
    
    Specified by:
    
    queryForRowSet in interface PersistentObjectDAO<T extends PersistentObject>
    
    Parameters:
    sql - SQL query to execute
    args - arguments to bind to the query (leaving it to the PreparedStatement to guess the corresponding SQL type); may also contain SqlParameterValue objects which indicate not only the argument value but also the SQL type and optionally the scale
    maxRows - the new max rows limit; null means there is no limit
    
    Returns:
    the result row set
  - queryForList
```
public List queryForList(String sql,
                Class elementType)
```
    Description copied from interface: PersistentObjectDAO
    
    Execute a query for a result list, given static SQL. Uses a JDBC Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded queryForList method with null as argument array. The results will be mapped to a List (one entry for each row) of result objects, each of them matching the specified element type.
    
    Specified by:
    
    queryForList in interface PersistentObjectDAO<T extends PersistentObject>
    
    Parameters:
    sql - SQL query to execute
    elementType - the required type of element in the result list (for example, Integer.class)
    
    Returns:
    a List of objects that match the specified element type
  - queryForInt
```
public int queryForInt(String sql)
```
    Description copied from interface: PersistentObjectDAO
    
    Execute a query that results in an int value, given static SQL. Uses a JDBC Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded queryForInt method with null as argument array. This method is useful for running static SQL with a known outcome. The query is expected to be a single row/single column query that results in an int value.
    
    Specified by:
    
    queryForInt in interface PersistentObjectDAO<T extends PersistentObject>
    
    Parameters:
    sql - SQL query to execute
    
    Returns:
    the int value, or 0 in case of SQL NULL
  - queryForLong
```
public long queryForLong(String sql)
```
    Description copied from interface: PersistentObjectDAO
    
    Execute a query that results in an long value, given static SQL. Uses a JDBC Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement, use the overloaded queryForInt method with null as argument array. This method is useful for running static SQL with a known outcome. The query is expected to be a single row/single column query that results in a long value.
    
    Specified by:
    
    queryForLong in interface PersistentObjectDAO<T extends PersistentObject>
    
    Parameters:
    sql - SQL query to execute
    
    Returns:
    the long value, or 0 in case of SQL NULL
  - jdbcUpdate
```
public int jdbcUpdate(String statement)
```
    Description copied from interface: PersistentObjectDAO
    
    Executes the given SQL update statement
    
    Specified by:
    
    jdbcUpdate in interface PersistentObjectDAO<T extends PersistentObject>
  - deleteAll
```
public void deleteAll(Collection<T> entities)
```
    Description copied from interface: PersistentObjectDAO
    
    Deletes all entries form the database
    
    Specified by:
    
    deleteAll in interface PersistentObjectDAO<T extends PersistentObject>
    
    Parameters:
    entities - The entities to be deleted
  - bulkUpdate
```
public int bulkUpdate(String expression,
             Object[] values)
```
    Description copied from interface: PersistentObjectDAO
    
    Executes a bulk update as specified by the given expression
    
    Specified by:
    
    bulkUpdate in interface PersistentObjectDAO<T extends PersistentObject>
    
    Returns:
    the number of modified records
  - jdbcUpdate
```
public int jdbcUpdate(String statement,
             Object... args)
```
    Description copied from interface: PersistentObjectDAO
    
    Issue a single SQL update operation (such as an insert, update or delete statement) via a prepared statement, binding the given arguments.
    
    Specified by:
    
    jdbcUpdate in interface PersistentObjectDAO<T extends PersistentObject>
    
    Parameters:
    statement - SQL containing bind parameters
    args - arguments to bind to the query (leaving it to the PreparedStatement to guess the corresponding SQL type); may also contain SqlParameterValue objects which indicate not only the argument value but also the SQL type and optionally the scale
    
    Returns:
    the number of rows affected
  - getConnection
```
protected Connection getConnection()
                            throws SQLException
```
    Throws:
    
    SQLException
  - getDbms
```
public String getDbms()
```
    Description copied from interface: PersistentObjectDAO
    
    Get the DBMS currently connected( possible values are: mysql, hsqldb, oracle, mssql)
    
    Specified by:
    
    getDbms in interface PersistentObjectDAO<T extends PersistentObject>
  - isHsql
```
protected boolean isHsql()
```
  - isMySQL
```
protected boolean isMySQL()
```
  - isOracle
```
protected boolean isOracle()
```
  - isSqlServer
```
protected boolean isSqlServer()
```
  - getSessionFactory
```
public org.hibernate.SessionFactory getSessionFactory()
```

Class HibernatePersistentObjectDAO<T extends PersistentObject>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

log

entityClass

sessionFactory

Constructor Detail

HibernatePersistentObjectDAO

Method Detail

setSessionFactory

delete

findAll

findAllIds

findById

findByWhere

findByWhere

findByQuery

findIdsByWhere

findIdsByWhere

store

saveOrUpdate

flush

refresh

merge

evict

prepareQuery

initialize

getCurrentSession

query

queryForList

queryForRowSet

queryForList

queryForInt

queryForLong

jdbcUpdate

deleteAll

bulkUpdate

jdbcUpdate

getConnection

getDbms

isHsql

isMySQL

isOracle

isSqlServer

getSessionFactory