Interface PersistentObjectDAO<T extends PersistentObject>

    • Method Detail

      • store

        boolean store​(T entity)
               throws PersistenceException
        This method persists the entity object
        Parameters:
        entity - entity to be stored
        Returns:
        True if successfully stored in a database
        Throws:
        PersistenceException - raised in case of errors in the database
      • findById

        T findById​(long id)
        This method finds an entity by ID
        Parameters:
        id - ID of the entity
        Returns:
        Entity with given ID
      • findById

        T findById​(long id,
                   boolean initialize)
        This method finds an entity by ID
        Parameters:
        id - ID of the entity
        initialize - True if the instance's lazy collections have to be initialized
        Returns:
        Entity with given ID
      • findAll

        List<T> findAll()
        Finds all entities in the database
        Returns:
        The list of all entities
      • findAll

        List<T> findAll​(long tenantId)
        Finds all entities in a specific tenant.
        Parameters:
        tenantId - Identifier of the tenant to search in
        Returns:
        The list of all entities
      • findAllIds

        List<Long> findAllIds()
        Finds all entities ids
        Returns:
        The list of all entities ids
      • findAllIds

        List<Long> findAllIds​(long tenantId)
        Finds all entities ids in a specific tenant.
        Parameters:
        tenantId - Identifier of the tenant to search in
        Returns:
        The list of all entities ids
      • findByWhere

        List<T> findByWhere​(String where,
                            String order,
                            Integer max)
                     throws PersistenceException
        Finds all entities by the given expression. Use _entity alias to reference attributes in the where expression.
        Parameters:
        where - The where clause expression
        order - The order clause expression
        max - Maximum results number (optional)
        Returns:
        The list of marching entities
        Throws:
        PersistenceException - raised in case of errors in the database
      • findByWhere

        List<T> findByWhere​(String where,
                            Object[] values,
                            String order,
                            Integer max)
                     throws PersistenceException
        Finds all entities by the given expression. Use _entity alias to reference attributes in the where expression.
        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
        Throws:
        PersistenceException - raised in case of errors in the database
      • findByObjectQuery

        List<T> findByObjectQuery​(String query,
                                  Object[] values,
                                  Integer max)
                           throws PersistenceException
        Finds all entities by the given object query.
        Parameters:
        query - The query expression (for positional parameters, please use JPA-style: ?1, ?2 ...)
        values - Parameters used in the where expression
        max - Maximum results number (optional)
        Returns:
        The list of marching entities
        Throws:
        PersistenceException - raised in case of errors in the database
      • findByQuery

        List<Object> findByQuery​(String query,
                                 Object[] values,
                                 Integer max)
                          throws PersistenceException
        Find everything you want from the DB using the ORM query language
        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
        Throws:
        PersistenceException - raised in case of errors in the database
      • findIdsByWhere

        List<Long> findIdsByWhere​(String where,
                                  String order,
                                  Integer max)
                           throws PersistenceException
        Finds all entities ids by the given expression. Use _entity alias to reference attributes in the where expression.
        Parameters:
        where - The where clause expression
        order - The order clause expression
        max - Maximum results number (optional)
        Returns:
        The list of marching entities ids
        Throws:
        PersistenceException - raised in case of errors in the database
      • findIdsByWhere

        List<Long> findIdsByWhere​(String where,
                                  Object[] values,
                                  String order,
                                  Integer max)
                           throws PersistenceException
        Finds all entities ids by the given expression. Use _entity alias to reference attributes in the where expression.
        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
        Throws:
        PersistenceException - raised in case of errors in the database
      • initialize

        void initialize​(T entity)
        Initialises lazy loaded data such as collections
        Parameters:
        entity - The entity to be initialised
      • query

        List query​(String sql,
                   Object[] args,
                   org.springframework.jdbc.core.RowMapper rowMapper,
                   Integer maxRows)
            throws PersistenceException
        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.
        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
        rowMapper - object that will map one object per row
        Returns:
        the result List, containing mapped objects
        Throws:
        PersistenceException - raised in case of errors in the database
      • queryForRowSet

        org.springframework.jdbc.support.rowset.SqlRowSet queryForRowSet​(String sql,
                                                                         Object[] args,
                                                                         Integer maxRows)
                                                                  throws PersistenceException
        Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, returns a navigable RowSet
        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
        Throws:
        PersistenceException - raised in case of errors in the database
      • queryForList

        List queryForList​(String sql,
                          Object[] args,
                          Class elementType,
                          Integer maxRows)
                   throws PersistenceException
        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.
        Parameters:
        sql - SQL query to execute
        elementType - the required type of element in the result list (for example, Integer.class)
        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 - maximum number of returned records
        Returns:
        a List of objects that match the specified element type
        Throws:
        PersistenceException - raised in case of errors in the database
      • queryForList

        List queryForList​(String sql,
                          Class elementType)
                   throws PersistenceException
        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.
        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
        Throws:
        PersistenceException - raised in case of errors in the database
      • queryForInt

        int queryForInt​(String sql)
                 throws PersistenceException
        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.
        Parameters:
        sql - SQL query to execute
        Returns:
        the int value, or 0 in case of SQL NULL
        Throws:
        PersistenceException - raised in case of errors in the database
      • queryForLong

        long queryForLong​(String sql)
                   throws PersistenceException
        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.
        Parameters:
        sql - SQL query to execute
        Returns:
        the long value, or 0 in case of SQL NULL
        Throws:
        PersistenceException - raised in case of errors in the database
      • queryForString

        String queryForString​(String sql)
                       throws PersistenceException
        Execute a query that results in an string 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 string value.
        Parameters:
        sql - SQL query to execute
        Returns:
        the string value
        Throws:
        PersistenceException - raised in case of errors in the database
      • queryForObject

        Object queryForObject​(String sql,
                              Class type)
                       throws PersistenceException
        Execute a query that results in a Object value, given static SQL. Uses a JDBC Statement, not a PreparedStatement. If you want to execute a static query with a PreparedStatement. 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 object value.
        Parameters:
        sql - SQL query to execute
        type - The type of the returned value
        Returns:
        the object value
        Throws:
        PersistenceException - raised in case of errors in the database
      • delete

        boolean delete​(long id)
                throws PersistenceException
        This method deletes an entity. Same as delete(id, 1)
        Parameters:
        id - ID of the entity which should be deleted.
        Returns:
        if the record has been successfully deleted
        Throws:
        PersistenceException - raised in case of errors in the database
      • delete

        boolean delete​(long id,
                       int code)
                throws PersistenceException
        This method deletes an entity and you can give a deletion code
        Parameters:
        id - ID of the entity which should be deleted
        code - Deletion code
        Returns:
        if the record has been successfully deleted
        Throws:
        PersistenceException - raised in case of errors in the database
      • deleteAll

        void deleteAll​(Collection<T> entities,
                       int code)
                throws PersistenceException
        Deletes all entries form the database giving a specific deletion code
        Parameters:
        entities - The entities to be deleted
        code - The deletion code
        Throws:
        PersistenceException - raised in case of errors in the database
      • bulkUpdate

        int bulkUpdate​(String expression,
                       Object[] values)
                throws PersistenceException
        Executes a bulk update as specified by the given expression
        Parameters:
        expression - The update expression. (for positional parameters, please use JPA-style: ?1, ?2 ...)
        values - Optional array of parameters values
        Returns:
        the number of modified records
        Throws:
        PersistenceException - raised in case of errors in the database
      • jdbcUpdate

        int jdbcUpdate​(String statement)
                throws PersistenceException
        Executes the given SQL update statement
        Parameters:
        statement - the SQL statement to execute against the database
        Returns:
        the value returned by the database after execution
        Throws:
        PersistenceException - raised in case of errors in the database
      • jdbcUpdate

        int jdbcUpdate​(String statement,
                       Object... args)
                throws PersistenceException
        Issue a single SQL update operation (such as an insert, update or delete statement) via a prepared statement, binding the given arguments
        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
        Throws:
        PersistenceException - raised in case of errors in the database
      • getDbms

        String getDbms()
        Get the DBMS name currently connected(possible values are: mysql, hsqldb, oracle, mssql)
        Returns:
        the database identifier
      • isOracle

        boolean isOracle()