Class BasicBatcher<D extends BatchableData>

  • All Implemented Interfaces:
    AutoCloseable, AccessControlled, Batcher
    Direct Known Subclasses:
    FeatureBatcher, RawDataBatcher, ReporterBatcher

    public abstract class BasicBatcher<D extends BatchableData>
    extends AbstractBatcher
    implements AccessControlled
    This is an abstract class for batching functionallity. Add all objects and then call flush to send the batch to the database. BasicBatcher can also have a limit on the batch size, when the batch is full BasicBatcher will automatically call flush to send the current batch to the database.
    Version:
    2.0
    Author:
    Samuel, Nicklas
    Last modified
    $Date: 2014-06-10 13:27:02 +0200 (ti, 10 jun 2014) $
    • Field Detail

      • logParam

        protected static final org.slf4j.Logger logParam
        Log all parameter bindings to prepared statement.
      • debugEnabled

        protected static final boolean debugEnabled
        So we don't always have to call logParam.debug()
      • insertCountTotal

        private int insertCountTotal
        Counts the number of inserts done by the batcher.
      • dataClass

        private final Class<D extends BatchableData> dataClass
        The class of data objects accepted by this batcher.
      • entityName

        private final String entityName
        The entity name as known to Hibernate.
      • permissions

        private int permissions
        The logged in user's permission to this item. Calculated by the initPermissions(int, int) method.
      • metaData

        private final ClassMetadata metaData
        Hibernate metadata for the batchable object.
      • table

        private final Table table
        The table where items of this type are stored.
      • idPropertyName

        private final String idPropertyName
        The name of the ID property. Usually this is 'id'.
      • insertSql

        private final String insertSql
      • updateSql

        private final String updateSql
      • deleteSql

        private final String deleteSql
      • insertCount

        private int insertCount
      • updateCount

        private int updateCount
      • deleteCount

        private int deleteCount
      • totalCount

        private int totalCount
    • Constructor Detail

      • BasicBatcher

        BasicBatcher​(Session session,
                     Class<D> dataClass,
                     String entityName)
              throws BaseException
        Constructor that initiate everything.
        Parameters:
        dataClass - The class of the data objects that are accepted by this batcher
        entityName - The entity name of the data as known by Hibernate, use null to use the dataClass as the entity name
        Throws:
        BaseException - If there is an error
    • Method Detail

      • hasPermission

        public final boolean hasPermission​(Permission permission)
        Checks if the logged in user has the specified permission on this item. The default implementation only checks the role keys for permissions. A subclass may not override this method since it would make it possible to bypass security checks.

        Subclasses that needs to check other keys, should override the initPermissions(int,int) method instead.

        Specified by:
        hasPermission in interface AccessControlled
        Parameters:
        permission - A value from the Permission class
        Returns:
        TRUE if the user has the permission, FALSE otherwise
      • initPermissions

        void initPermissions​(int granted,
                             int denied)
                      throws BaseException
        Initialise the logged in user's permissions for this batcher. The default implementation checks the role keys.

        Subclasses that needs to check other keys or properties, such as the RawDataBatcher should override this method. The subclass should calculate additional permissions to be granted or denied, and combine those with whatever was passed as parameters. Use the binary OR operator ( | ) to combine the permissions. Finally the subclass must call super.initPermissions(granted, denied).

        Parameters:
        granted - Permissions that have been granted by the subclass
        denied - Permissions that have been denied by the subclass
        Throws:
        BaseException - If the permissions couldn't be initialised
      • flushInsert

        public void flushInsert()
                         throws BaseException
        Flush the SQL insert command buffer. Sends the remaining SQL commands in the batch to the database for execution.
        Throws:
        BaseException - Thrown if there is a database error.
      • flushUpdate

        public void flushUpdate()
                         throws BaseException
        Flush the SQL insert command buffer. Sends the remaining SQL commands in the batch to the database for execution.
        Throws:
        BaseException - Thrown if there is a database error.
      • flushDelete

        public void flushDelete()
                         throws BaseException
        Flush the SQL delete command buffer. Sends the remaining SQL commands in the batch to the database for execution.
        Throws:
        BaseException - Thrown if there is a database error.
      • addToBatch

        private void addToBatch​(D data,
                                PreparedStatement ps,
                                List<BatchedPropertyInfo> propertyOrder)
                         throws DatabaseException
        Add the data object to the batch represented by the prepared statement
        Parameters:
        data - Data object to get property values from
        ps - The prepared statement to add the data object to
        propertyOrder - The property names of the parameter order in the prepared statement
        Throws:
        DatabaseException - If there is an error
      • setPropertyValue

        void setPropertyValue​(D data,
                              String propertyName,
                              Object value)
        Set a protected property value on a data object using Hibernate built-in reflection methods.
        Parameters:
        data - The data object to set the property on
        propertyName - The name of the property, ie. same as getXxx method name minus the get part
        value - The value to give to the property
      • getPropertyValue

        Object getPropertyValue​(D data,
                                String propertyName)
        Get the value of a protected property value on a data object using Hibernate built-in reflection methods.
        Parameters:
        data - The data object to set the property on
        propertyName - The name of the property, ie. same as getXxx method name minus the get part
        Returns:
        The value of the property
      • onBeforeCommit

        void onBeforeCommit​(D data,
                            Transactional.Action action)
                     throws BaseException
        Called after the object has been validated just before the SQL is added to the batch queue.
        Parameters:
        data - Object to update
        action - The action
        Throws:
        BaseException
      • validate

        public abstract void validate​(D data)
                               throws InvalidDataException
        Validate the data, since no validation is possible in set methods of the data object. Ie. this is very similar to case 2 validation for items.
        Parameters:
        data - Data object to validate
        Throws:
        InvalidDataException - If the data object is invalid
      • getType

        public abstract Item getType()
        Get the type of item supported by the batcher. The returned value is one of the values defined in the Item enumeration.
        Returns:
        A value indicating the type of item
        See Also:
        Item
      • getTotalInsertCount

        public int getTotalInsertCount()
        Gets the total number of inserts done by the batcher