Package com.github.collinalpert.java2db.services

Class BaseService<T extends BaseEntity>

  • Direct Known Subclasses:
    BaseCodeAndDescriptionService
    public class BaseService<T extends BaseEntity>
extends java.lang.Object
    Class that provides base functionality for all service classes. Every service class must extend this class.
    Author:
    Collin Alpert

    • Constructor Summary

      Constructors 
      Modifier Constructor Description
      protected BaseService()
      Constructor for the base class of all services.

    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      boolean any()
      Checks if a table has at least one row.
      boolean any​(com.github.collinalpert.lambda2sql.functions.SqlPredicate<T> predicate)
      Checks if a value matching the condition exists in the table.
      long count()
      An overload of the count(SqlPredicate) method.
      long count​(com.github.collinalpert.lambda2sql.functions.SqlPredicate<T> predicate)
      Counts the rows that have an id (which should usually be every row) and match a certain condition.
      void create​(java.util.List<T> instances)
      Creates multiple entities on the database.
      long create​(T instance)
      Creates this Java entity on the database.
      void create​(T... instances)
      Creates a variable amount of entities on the database.
      PaginationResult<T> createPagination​(int entriesPerPage)
      Creates a pagination structure that splits the entire table into multiple pages.
      CacheablePaginationResult<T> createPagination​(int entriesPerPage, java.time.Duration cacheExpiration)
      Creates a pagination structure that splits the entire table into multiple pages.
      PaginationResult<T> createPagination​(com.github.collinalpert.lambda2sql.functions.SqlPredicate<T> predicate, int entriesPerPage)
      Creates a pagination structure that splits the result of a query into multiple pages.
      CacheablePaginationResult<T> createPagination​(com.github.collinalpert.lambda2sql.functions.SqlPredicate<T> predicate, int entriesPerPage, java.time.Duration cacheExpiration)
      Creates a cached pagination structure that splits the result of a query into multiple pages.
      protected Query<T> createQuery()  
      void delete​(long id)
      Deletes a row by an id.
      void delete​(long... ids)
      Deletes multiple rows with the corresponding ids.
      void delete​(com.github.collinalpert.lambda2sql.functions.SqlPredicate<T> predicate)
      Deletes rows based on a condition.
      void delete​(java.util.List<T> entities)
      Deletes a list of entities at once.
      void delete​(T instance)
      Deletes the corresponding row on the database.
      void delete​(T... entities)
      Deletes multiple entities at once.
      java.util.List<T> getAll()  
      java.util.List<T> getAll​(int limit)
      Gets all values from the table but limits the result.
      java.util.List<T> getAll​(com.github.collinalpert.lambda2sql.functions.SqlFunction<T,​?> orderBy)
      Gets all values from the table and orders them in an ascending order.
      java.util.List<T> getAll​(com.github.collinalpert.lambda2sql.functions.SqlFunction<T,​?> orderBy, int limit)
      Gets all values from the table, orders them in an ascending order and limits the result.
      java.util.List<T> getAll​(com.github.collinalpert.lambda2sql.functions.SqlFunction<T,​?> orderBy, OrderTypes sortingType)
      Gets all values from the table and orders them in the specified order.
      java.util.List<T> getAll​(com.github.collinalpert.lambda2sql.functions.SqlFunction<T,​?> orderBy, OrderTypes sortingType, int limit)
      Gets all values from the table, orders them in a specific order and limits the result.
      java.util.Optional<T> getById​(long id)  
      Query<T> getMultiple​(com.github.collinalpert.lambda2sql.functions.SqlPredicate<T> predicate)
      Retrieves list of entities which match the predicate.
      java.util.Optional<T> getSingle​(com.github.collinalpert.lambda2sql.functions.SqlPredicate<T> predicate)
      Retrieves a single entity which matches the predicate.
      boolean hasDuplicates​(com.github.collinalpert.lambda2sql.functions.SqlFunction<T,​?> column)
      Checks if duplicate values exist for a specific column in a table.
      void truncateTable()
      Truncates the corresponding table on the database.
      <R> void update​(long entityId, com.github.collinalpert.lambda2sql.functions.SqlFunction<T,​R> column, R newValue)
      Updates a specific column for a record in a table.
      void update​(T instance)
      Updates this entity's row on the database.

      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    • Constructor Detail

      • BaseService

        protected BaseService()
        Constructor for the base class of all services. It is not possible to create instances of it.

    • Method Detail

      • create

        public long create​(T instance)
            throws java.sql.SQLException
        Creates this Java entity on the database.
        Parameters:
        instance - The instance to create on the database.
        Returns:
        The id of the newly created record.
        Throws:
        java.sql.SQLException - if the query cannot be executed due to database constraints i.e. non-existing default value for field or an incorrect data type or a foreign key constraint.

      • create

        @SafeVarargs
public final void create​(T... instances)
                  throws java.sql.SQLException
        Creates a variable amount of entities on the database.
        Parameters:
        instances - The instances to create.
        Throws:
        java.sql.SQLException - if the query cannot be executed due to database constraints i.e. non-existing default value for field or an incorrect data type or a foreign key constraint.
        See Also:
        create(List)

      • create

        public void create​(java.util.List<T> instances)
            throws java.sql.SQLException
        Creates multiple entities on the database. It is recommended to use this method instead of iterating over the list and calling a normal create(BaseEntity) on each entity separately.
        Parameters:
        instances - The list of entities to create on the database.
        Throws:
        java.sql.SQLException - if the query cannot be executed due to database constraints i.e. non-existing default value for field or an incorrect data type or a foreign key constraint.

      • count

        public long count()
        An overload of the count(SqlPredicate) method. It will count all the rows that have an id, since this should be a reasonable criteria. Use with caution, as this call can take quite a while.
        Returns:
        The amount of rows in this table.

      • count

        public long count​(com.github.collinalpert.lambda2sql.functions.SqlPredicate<T> predicate)
        Counts the rows that have an id (which should usually be every row) and match a certain condition. Note that COUNT operations usually are very slow.
        Parameters:
        predicate - The condition to test for.
        Returns:
        The number of rows matching the condition.

      • any

        public boolean any()
        Checks if a table has at least one row.
        Returns:
        True if at least one row exists in the table, false if not.

      • any

        public boolean any​(com.github.collinalpert.lambda2sql.functions.SqlPredicate<T> predicate)
        Checks if a value matching the condition exists in the table.
        Parameters:
        predicate - The condition to check for.
        Returns:
        True if the predicate matches one or more records, false if not.

      • hasDuplicates

        public boolean hasDuplicates​(com.github.collinalpert.lambda2sql.functions.SqlFunction<T,​?> column)
        Checks if duplicate values exist for a specific column in a table.
        Parameters:
        column - The column to check for duplicate values for.
        Returns:
        True if there is at least one duplicate value in the specified column, false otherwise.

      • getSingle

        public java.util.Optional<T> getSingle​(com.github.collinalpert.lambda2sql.functions.SqlPredicate<T> predicate)
        Retrieves a single entity which matches the predicate.
        Parameters:
        predicate - The SqlPredicate to add constraints to a DQL query.
        Returns:
        An entity matching the result of the query.

      • getMultiple

        public Query<T> getMultiple​(com.github.collinalpert.lambda2sql.functions.SqlPredicate<T> predicate)
        Retrieves list of entities which match the predicate.
        Parameters:
        predicate - The SqlPredicate to add constraints to a DQL statement.
        Returns:
        A list of entities matching the result of the query.

      • getById

        public java.util.Optional<T> getById​(long id)
        Parameters:
        id - The id of the desired entity.
        Returns:
        Gets an entity by its id.

      • getAll

        public java.util.List<T> getAll()
        Returns:
        All entities in this table.

      • getAll

        public java.util.List<T> getAll​(int limit)
        Gets all values from the table but limits the result.
        Parameters:
        limit - The maximum of records to return.
        Returns:
        A list with the maximum size of the parameter specified.

      • getAll

        public java.util.List<T> getAll​(com.github.collinalpert.lambda2sql.functions.SqlFunction<T,​?> orderBy)
        Gets all values from the table and orders them in an ascending order.
        Parameters:
        orderBy - The property to order by.
        Returns:
        A list of all records ordered by a specific property in an ascending order.

      • getAll

        public java.util.List<T> getAll​(com.github.collinalpert.lambda2sql.functions.SqlFunction<T,​?> orderBy,
                                OrderTypes sortingType)
        Gets all values from the table and orders them in the specified order.
        Parameters:
        orderBy - The property to order by.
        sortingType - The order direction. Can be either ascending or descending.
        Returns:
        A list of all records ordered by a specific property in the specified order.

      • getAll

        public java.util.List<T> getAll​(com.github.collinalpert.lambda2sql.functions.SqlFunction<T,​?> orderBy,
                                int limit)
        Gets all values from the table, orders them in an ascending order and limits the result.
        Parameters:
        orderBy - The property to order by.
        limit - The maximum records to return.
        Returns:
        A list with the maximum size of the parameter specified and in an ascending order.

      • getAll

        public java.util.List<T> getAll​(com.github.collinalpert.lambda2sql.functions.SqlFunction<T,​?> orderBy,
                                OrderTypes sortingType,
                                int limit)
        Gets all values from the table, orders them in a specific order and limits the result.
        Parameters:
        orderBy - The property to order by.
        sortingType - The order direction. Can be either ascending or descending.
        limit - The maximum records to return.
        Returns:
        A list with the maximum size of the parameter specified and in an ascending order.

      • createPagination

        public PaginationResult<T> createPagination​(int entriesPerPage)
        Creates a pagination structure that splits the entire table into multiple pages. Note that the query to the database for each page is only executed when that specific page is requested and not when this method is called.
        Parameters:
        entriesPerPage - The number of entries to be displayed on each page.
        Returns:
        A pagination which splits up an entire table into multiple pages.

      • createPagination

        public PaginationResult<T> createPagination​(com.github.collinalpert.lambda2sql.functions.SqlPredicate<T> predicate,
                                            int entriesPerPage)
        Creates a pagination structure that splits the result of a query into multiple pages. Note that the query to the database for each page is only executed when that specific page is requested and not when this method is called. The predicate to filter by.
        Parameters:
        predicate - The predicate to filter by.
        entriesPerPage - The number of entries to be displayed on each page.
        Returns:
        A pagination which splits the result of a condition into multiple pages.

      • createPagination

        public CacheablePaginationResult<T> createPagination​(int entriesPerPage,
                                                     java.time.Duration cacheExpiration)
        Creates a pagination structure that splits the entire table into multiple pages. Note that the query to the database for each page is only executed when that specific page is requested and not when this method is called. When pages are retrieved, they are stored in a cache, so they can be retrieved from there the next time they are requested. Note that this will work, until the specified cacheExpiration is up. After that, the next time a page is requested, it will be reloaded from the database.
        Parameters:
        entriesPerPage - The number of entries to be displayed on each page.
        cacheExpiration - The time a page is valid in the cache. If a page is requested and in the cache, but expired, it will be retrieved from the database again and re-stored in the cache.
        Returns:
        A pagination which displays a entire table

      • createPagination

        public CacheablePaginationResult<T> createPagination​(com.github.collinalpert.lambda2sql.functions.SqlPredicate<T> predicate,
                                                     int entriesPerPage,
                                                     java.time.Duration cacheExpiration)
        Creates a cached pagination structure that splits the result of a query into multiple pages. Note that the query to the database for each page is only executed when that specific page is requested and not when this method is called. When pages are retrieved, they are stored in a cache, so they can be retrieved from there the next time they are requested. Note that this will work, until the specified cacheExpiration is up. After that, the next time a page is requested, it will be reloaded from the database.
        Parameters:
        predicate - The predicate to filter by.
        entriesPerPage - The number of entries to be displayed on each page.
        cacheExpiration - The time a page is valid in the cache. If a page is requested and in the cache, but expired, it will be retrieved from the database again and re-stored in the cache.
        Returns:
        A pagination which allows the developer to retrieve specific pages from the result.

      • update

        public void update​(T instance)
            throws java.sql.SQLException
        Updates this entity's row on the database.
        Parameters:
        instance - The instance to update on the database.
        Throws:
        java.sql.SQLException - if the query cannot be executed due to database constraints i.e. non-existing default value for field or an incorrect data type.

      • update

        public <R> void update​(long entityId,
                       com.github.collinalpert.lambda2sql.functions.SqlFunction<T,​R> column,
                       R newValue)
                throws java.sql.SQLException
        Updates a specific column for a record in a table.
        Type Parameters:
        R - The data type of the column. It must be the same as the data type of the new value.
        Parameters:
        entityId - The id of the record.
        column - The column to update.
        newValue - The new value of the column.
        Throws:
        java.sql.SQLException - if the query cannot be executed due to database constraints i.e. non-existing default value for field or an incorrect data type.

      • delete

        public void delete​(T instance)
            throws java.sql.SQLException
        Deletes the corresponding row on the database.
        Parameters:
        instance - The instance to delete on the database.
        Throws:
        java.sql.SQLException - for example because of a foreign key constraint.

      • delete

        public void delete​(long id)
            throws java.sql.SQLException
        Deletes a row by an id.
        Parameters:
        id - The row with this id to delete.
        Throws:
        java.sql.SQLException - for example because of a foreign key constraint.

      • delete

        public void delete​(java.util.List<T> entities)
            throws java.sql.SQLException
        Deletes a list of entities at once.
        Parameters:
        entities - The list of entities to delete.
        Throws:
        java.sql.SQLException - for example because of a foreign key constraint.

      • delete

        @SafeVarargs
public final void delete​(T... entities)
                  throws java.sql.SQLException
        Deletes multiple entities at once.
        Parameters:
        entities - A variable amount of entities.
        Throws:
        java.sql.SQLException - for example because of a foreign key constraint.
        See Also:
        delete(List)

      • delete

        public void delete​(long... ids)
            throws java.sql.SQLException
        Deletes multiple rows with the corresponding ids.
        Parameters:
        ids - The ids to delete the rows by.
        Throws:
        java.sql.SQLException - for example because of a foreign key constraint.

      • delete

        public void delete​(com.github.collinalpert.lambda2sql.functions.SqlPredicate<T> predicate)
            throws java.sql.SQLException
        Deletes rows based on a condition.
        Parameters:
        predicate - The condition to delete by.
        Throws:
        java.sql.SQLException - in case the condition cannot be applied or if a foreign key constraint fails.

      • truncateTable

        public void truncateTable()
                   throws java.sql.SQLException
        Truncates the corresponding table on the database.
        Throws:
        java.sql.SQLException - for example because a foreign key references this table. Note that you will not be able to truncate a table, even if no foreign key references a row in this table. TRUNCATE is a DDL command and cannot check if rows are being referenced or not.