Object
com.liferay.portal.kernel.service.persistence.CountryUtil

public class CountryUtil extends Object
The persistence utility for the country service. This utility wraps com.liferay.portal.service.persistence.impl.CountryPersistenceImpl and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.

Caching information and settings can be found in portal.properties

Author:
Brian Wing Shun Chan
See Also:
{$generated.description}
  • Constructor Details

    • CountryUtil

      public CountryUtil()
  • Method Details

    • clearCache

      public static void clearCache()
      See Also:
    • clearCache

      public static void clearCache(Country country)
      See Also:
    • countWithDynamicQuery

      public static long countWithDynamicQuery(DynamicQuery dynamicQuery)
      See Also:
    • fetchByPrimaryKeys

      public static Map<Serializable,Country> fetchByPrimaryKeys(Set<Serializable> primaryKeys)
      See Also:
    • findWithDynamicQuery

      public static List<Country> findWithDynamicQuery(DynamicQuery dynamicQuery)
      See Also:
    • findWithDynamicQuery

      public static List<Country> findWithDynamicQuery(DynamicQuery dynamicQuery, int start, int end)
      See Also:
    • findWithDynamicQuery

      public static List<Country> findWithDynamicQuery(DynamicQuery dynamicQuery, int start, int end, OrderByComparator<Country> orderByComparator)
      See Also:
    • update

      public static Country update(Country country)
      See Also:
    • update

      public static Country update(Country country, ServiceContext serviceContext)
      See Also:
    • findByUuid

      public static List<Country> findByUuid(String uuid)
      Returns all the countries where uuid = ?.
      Parameters:
      uuid - the uuid
      Returns:
      the matching countries
    • findByUuid

      public static List<Country> findByUuid(String uuid, int start, int end)
      Returns a range of all the countries where uuid = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      uuid - the uuid
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      Returns:
      the range of matching countries
    • findByUuid

      public static List<Country> findByUuid(String uuid, int start, int end, OrderByComparator<Country> orderByComparator)
      Returns an ordered range of all the countries where uuid = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      uuid - the uuid
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching countries
    • findByUuid

      public static List<Country> findByUuid(String uuid, int start, int end, OrderByComparator<Country> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the countries where uuid = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      uuid - the uuid
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching countries
    • findByUuid_First

      public static Country findByUuid_First(String uuid, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the first country in the ordered set where uuid = ?.
      Parameters:
      uuid - the uuid
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching country
      Throws:
      NoSuchCountryException - if a matching country could not be found
      NoSuchCountryException
    • fetchByUuid_First

      public static Country fetchByUuid_First(String uuid, OrderByComparator<Country> orderByComparator)
      Returns the first country in the ordered set where uuid = ?.
      Parameters:
      uuid - the uuid
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching country, or null if a matching country could not be found
    • findByUuid_Last

      public static Country findByUuid_Last(String uuid, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the last country in the ordered set where uuid = ?.
      Parameters:
      uuid - the uuid
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching country
      Throws:
      NoSuchCountryException - if a matching country could not be found
      NoSuchCountryException
    • fetchByUuid_Last

      public static Country fetchByUuid_Last(String uuid, OrderByComparator<Country> orderByComparator)
      Returns the last country in the ordered set where uuid = ?.
      Parameters:
      uuid - the uuid
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching country, or null if a matching country could not be found
    • findByUuid_PrevAndNext

      public static Country[] findByUuid_PrevAndNext(long countryId, String uuid, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the countries before and after the current country in the ordered set where uuid = ?.
      Parameters:
      countryId - the primary key of the current country
      uuid - the uuid
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the previous, current, and next country
      Throws:
      NoSuchCountryException - if a country with the primary key could not be found
      NoSuchCountryException
    • removeByUuid

      public static void removeByUuid(String uuid)
      Removes all the countries where uuid = ? from the database.
      Parameters:
      uuid - the uuid
    • countByUuid

      public static int countByUuid(String uuid)
      Returns the number of countries where uuid = ?.
      Parameters:
      uuid - the uuid
      Returns:
      the number of matching countries
    • findByUuid_C

      public static List<Country> findByUuid_C(String uuid, long companyId)
      Returns all the countries where uuid = ? and companyId = ?.
      Parameters:
      uuid - the uuid
      companyId - the company ID
      Returns:
      the matching countries
    • findByUuid_C

      public static List<Country> findByUuid_C(String uuid, long companyId, int start, int end)
      Returns a range of all the countries where uuid = ? and companyId = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      uuid - the uuid
      companyId - the company ID
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      Returns:
      the range of matching countries
    • findByUuid_C

      public static List<Country> findByUuid_C(String uuid, long companyId, int start, int end, OrderByComparator<Country> orderByComparator)
      Returns an ordered range of all the countries where uuid = ? and companyId = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      uuid - the uuid
      companyId - the company ID
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching countries
    • findByUuid_C

      public static List<Country> findByUuid_C(String uuid, long companyId, int start, int end, OrderByComparator<Country> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the countries where uuid = ? and companyId = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      uuid - the uuid
      companyId - the company ID
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching countries
    • findByUuid_C_First

      public static Country findByUuid_C_First(String uuid, long companyId, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the first country in the ordered set where uuid = ? and companyId = ?.
      Parameters:
      uuid - the uuid
      companyId - the company ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching country
      Throws:
      NoSuchCountryException - if a matching country could not be found
      NoSuchCountryException
    • fetchByUuid_C_First

      public static Country fetchByUuid_C_First(String uuid, long companyId, OrderByComparator<Country> orderByComparator)
      Returns the first country in the ordered set where uuid = ? and companyId = ?.
      Parameters:
      uuid - the uuid
      companyId - the company ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching country, or null if a matching country could not be found
    • findByUuid_C_Last

      public static Country findByUuid_C_Last(String uuid, long companyId, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the last country in the ordered set where uuid = ? and companyId = ?.
      Parameters:
      uuid - the uuid
      companyId - the company ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching country
      Throws:
      NoSuchCountryException - if a matching country could not be found
      NoSuchCountryException
    • fetchByUuid_C_Last

      public static Country fetchByUuid_C_Last(String uuid, long companyId, OrderByComparator<Country> orderByComparator)
      Returns the last country in the ordered set where uuid = ? and companyId = ?.
      Parameters:
      uuid - the uuid
      companyId - the company ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching country, or null if a matching country could not be found
    • findByUuid_C_PrevAndNext

      public static Country[] findByUuid_C_PrevAndNext(long countryId, String uuid, long companyId, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the countries before and after the current country in the ordered set where uuid = ? and companyId = ?.
      Parameters:
      countryId - the primary key of the current country
      uuid - the uuid
      companyId - the company ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the previous, current, and next country
      Throws:
      NoSuchCountryException - if a country with the primary key could not be found
      NoSuchCountryException
    • removeByUuid_C

      public static void removeByUuid_C(String uuid, long companyId)
      Removes all the countries where uuid = ? and companyId = ? from the database.
      Parameters:
      uuid - the uuid
      companyId - the company ID
    • countByUuid_C

      public static int countByUuid_C(String uuid, long companyId)
      Returns the number of countries where uuid = ? and companyId = ?.
      Parameters:
      uuid - the uuid
      companyId - the company ID
      Returns:
      the number of matching countries
    • findByCompanyId

      public static List<Country> findByCompanyId(long companyId)
      Returns all the countries where companyId = ?.
      Parameters:
      companyId - the company ID
      Returns:
      the matching countries
    • findByCompanyId

      public static List<Country> findByCompanyId(long companyId, int start, int end)
      Returns a range of all the countries where companyId = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      companyId - the company ID
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      Returns:
      the range of matching countries
    • findByCompanyId

      public static List<Country> findByCompanyId(long companyId, int start, int end, OrderByComparator<Country> orderByComparator)
      Returns an ordered range of all the countries where companyId = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      companyId - the company ID
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching countries
    • findByCompanyId

      public static List<Country> findByCompanyId(long companyId, int start, int end, OrderByComparator<Country> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the countries where companyId = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      companyId - the company ID
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching countries
    • findByCompanyId_First

      public static Country findByCompanyId_First(long companyId, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the first country in the ordered set where companyId = ?.
      Parameters:
      companyId - the company ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching country
      Throws:
      NoSuchCountryException - if a matching country could not be found
      NoSuchCountryException
    • fetchByCompanyId_First

      public static Country fetchByCompanyId_First(long companyId, OrderByComparator<Country> orderByComparator)
      Returns the first country in the ordered set where companyId = ?.
      Parameters:
      companyId - the company ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching country, or null if a matching country could not be found
    • findByCompanyId_Last

      public static Country findByCompanyId_Last(long companyId, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the last country in the ordered set where companyId = ?.
      Parameters:
      companyId - the company ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching country
      Throws:
      NoSuchCountryException - if a matching country could not be found
      NoSuchCountryException
    • fetchByCompanyId_Last

      public static Country fetchByCompanyId_Last(long companyId, OrderByComparator<Country> orderByComparator)
      Returns the last country in the ordered set where companyId = ?.
      Parameters:
      companyId - the company ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching country, or null if a matching country could not be found
    • findByCompanyId_PrevAndNext

      public static Country[] findByCompanyId_PrevAndNext(long countryId, long companyId, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the countries before and after the current country in the ordered set where companyId = ?.
      Parameters:
      countryId - the primary key of the current country
      companyId - the company ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the previous, current, and next country
      Throws:
      NoSuchCountryException - if a country with the primary key could not be found
      NoSuchCountryException
    • removeByCompanyId

      public static void removeByCompanyId(long companyId)
      Removes all the countries where companyId = ? from the database.
      Parameters:
      companyId - the company ID
    • countByCompanyId

      public static int countByCompanyId(long companyId)
      Returns the number of countries where companyId = ?.
      Parameters:
      companyId - the company ID
      Returns:
      the number of matching countries
    • findByActive

      public static List<Country> findByActive(boolean active)
      Returns all the countries where active = ?.
      Parameters:
      active - the active
      Returns:
      the matching countries
    • findByActive

      public static List<Country> findByActive(boolean active, int start, int end)
      Returns a range of all the countries where active = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      active - the active
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      Returns:
      the range of matching countries
    • findByActive

      public static List<Country> findByActive(boolean active, int start, int end, OrderByComparator<Country> orderByComparator)
      Returns an ordered range of all the countries where active = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      active - the active
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching countries
    • findByActive

      public static List<Country> findByActive(boolean active, int start, int end, OrderByComparator<Country> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the countries where active = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      active - the active
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching countries
    • findByActive_First

      public static Country findByActive_First(boolean active, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the first country in the ordered set where active = ?.
      Parameters:
      active - the active
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching country
      Throws:
      NoSuchCountryException - if a matching country could not be found
      NoSuchCountryException
    • fetchByActive_First

      public static Country fetchByActive_First(boolean active, OrderByComparator<Country> orderByComparator)
      Returns the first country in the ordered set where active = ?.
      Parameters:
      active - the active
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching country, or null if a matching country could not be found
    • findByActive_Last

      public static Country findByActive_Last(boolean active, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the last country in the ordered set where active = ?.
      Parameters:
      active - the active
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching country
      Throws:
      NoSuchCountryException - if a matching country could not be found
      NoSuchCountryException
    • fetchByActive_Last

      public static Country fetchByActive_Last(boolean active, OrderByComparator<Country> orderByComparator)
      Returns the last country in the ordered set where active = ?.
      Parameters:
      active - the active
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching country, or null if a matching country could not be found
    • findByActive_PrevAndNext

      public static Country[] findByActive_PrevAndNext(long countryId, boolean active, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the countries before and after the current country in the ordered set where active = ?.
      Parameters:
      countryId - the primary key of the current country
      active - the active
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the previous, current, and next country
      Throws:
      NoSuchCountryException - if a country with the primary key could not be found
      NoSuchCountryException
    • removeByActive

      public static void removeByActive(boolean active)
      Removes all the countries where active = ? from the database.
      Parameters:
      active - the active
    • countByActive

      public static int countByActive(boolean active)
      Returns the number of countries where active = ?.
      Parameters:
      active - the active
      Returns:
      the number of matching countries
    • findByC_A2

      public static Country findByC_A2(long companyId, String a2) throws NoSuchCountryException
      Returns the country where companyId = ? and a2 = ? or throws a NoSuchCountryException if it could not be found.
      Parameters:
      companyId - the company ID
      a2 - the a2
      Returns:
      the matching country
      Throws:
      NoSuchCountryException - if a matching country could not be found
      NoSuchCountryException
    • fetchByC_A2

      public static Country fetchByC_A2(long companyId, String a2)
      Returns the country where companyId = ? and a2 = ? or returns null if it could not be found. Uses the finder cache.
      Parameters:
      companyId - the company ID
      a2 - the a2
      Returns:
      the matching country, or null if a matching country could not be found
    • fetchByC_A2

      public static Country fetchByC_A2(long companyId, String a2, boolean useFinderCache)
      Returns the country where companyId = ? and a2 = ? or returns null if it could not be found, optionally using the finder cache.
      Parameters:
      companyId - the company ID
      a2 - the a2
      useFinderCache - whether to use the finder cache
      Returns:
      the matching country, or null if a matching country could not be found
    • removeByC_A2

      public static Country removeByC_A2(long companyId, String a2) throws NoSuchCountryException
      Removes the country where companyId = ? and a2 = ? from the database.
      Parameters:
      companyId - the company ID
      a2 - the a2
      Returns:
      the country that was removed
      Throws:
      NoSuchCountryException
    • countByC_A2

      public static int countByC_A2(long companyId, String a2)
      Returns the number of countries where companyId = ? and a2 = ?.
      Parameters:
      companyId - the company ID
      a2 - the a2
      Returns:
      the number of matching countries
    • findByC_A3

      public static Country findByC_A3(long companyId, String a3) throws NoSuchCountryException
      Returns the country where companyId = ? and a3 = ? or throws a NoSuchCountryException if it could not be found.
      Parameters:
      companyId - the company ID
      a3 - the a3
      Returns:
      the matching country
      Throws:
      NoSuchCountryException - if a matching country could not be found
      NoSuchCountryException
    • fetchByC_A3

      public static Country fetchByC_A3(long companyId, String a3)
      Returns the country where companyId = ? and a3 = ? or returns null if it could not be found. Uses the finder cache.
      Parameters:
      companyId - the company ID
      a3 - the a3
      Returns:
      the matching country, or null if a matching country could not be found
    • fetchByC_A3

      public static Country fetchByC_A3(long companyId, String a3, boolean useFinderCache)
      Returns the country where companyId = ? and a3 = ? or returns null if it could not be found, optionally using the finder cache.
      Parameters:
      companyId - the company ID
      a3 - the a3
      useFinderCache - whether to use the finder cache
      Returns:
      the matching country, or null if a matching country could not be found
    • removeByC_A3

      public static Country removeByC_A3(long companyId, String a3) throws NoSuchCountryException
      Removes the country where companyId = ? and a3 = ? from the database.
      Parameters:
      companyId - the company ID
      a3 - the a3
      Returns:
      the country that was removed
      Throws:
      NoSuchCountryException
    • countByC_A3

      public static int countByC_A3(long companyId, String a3)
      Returns the number of countries where companyId = ? and a3 = ?.
      Parameters:
      companyId - the company ID
      a3 - the a3
      Returns:
      the number of matching countries
    • findByC_Active

      public static List<Country> findByC_Active(long companyId, boolean active)
      Returns all the countries where companyId = ? and active = ?.
      Parameters:
      companyId - the company ID
      active - the active
      Returns:
      the matching countries
    • findByC_Active

      public static List<Country> findByC_Active(long companyId, boolean active, int start, int end)
      Returns a range of all the countries where companyId = ? and active = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      companyId - the company ID
      active - the active
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      Returns:
      the range of matching countries
    • findByC_Active

      public static List<Country> findByC_Active(long companyId, boolean active, int start, int end, OrderByComparator<Country> orderByComparator)
      Returns an ordered range of all the countries where companyId = ? and active = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      companyId - the company ID
      active - the active
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching countries
    • findByC_Active

      public static List<Country> findByC_Active(long companyId, boolean active, int start, int end, OrderByComparator<Country> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the countries where companyId = ? and active = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      companyId - the company ID
      active - the active
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching countries
    • findByC_Active_First

      public static Country findByC_Active_First(long companyId, boolean active, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the first country in the ordered set where companyId = ? and active = ?.
      Parameters:
      companyId - the company ID
      active - the active
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching country
      Throws:
      NoSuchCountryException - if a matching country could not be found
      NoSuchCountryException
    • fetchByC_Active_First

      public static Country fetchByC_Active_First(long companyId, boolean active, OrderByComparator<Country> orderByComparator)
      Returns the first country in the ordered set where companyId = ? and active = ?.
      Parameters:
      companyId - the company ID
      active - the active
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching country, or null if a matching country could not be found
    • findByC_Active_Last

      public static Country findByC_Active_Last(long companyId, boolean active, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the last country in the ordered set where companyId = ? and active = ?.
      Parameters:
      companyId - the company ID
      active - the active
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching country
      Throws:
      NoSuchCountryException - if a matching country could not be found
      NoSuchCountryException
    • fetchByC_Active_Last

      public static Country fetchByC_Active_Last(long companyId, boolean active, OrderByComparator<Country> orderByComparator)
      Returns the last country in the ordered set where companyId = ? and active = ?.
      Parameters:
      companyId - the company ID
      active - the active
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching country, or null if a matching country could not be found
    • findByC_Active_PrevAndNext

      public static Country[] findByC_Active_PrevAndNext(long countryId, long companyId, boolean active, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the countries before and after the current country in the ordered set where companyId = ? and active = ?.
      Parameters:
      countryId - the primary key of the current country
      companyId - the company ID
      active - the active
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the previous, current, and next country
      Throws:
      NoSuchCountryException - if a country with the primary key could not be found
      NoSuchCountryException
    • removeByC_Active

      public static void removeByC_Active(long companyId, boolean active)
      Removes all the countries where companyId = ? and active = ? from the database.
      Parameters:
      companyId - the company ID
      active - the active
    • countByC_Active

      public static int countByC_Active(long companyId, boolean active)
      Returns the number of countries where companyId = ? and active = ?.
      Parameters:
      companyId - the company ID
      active - the active
      Returns:
      the number of matching countries
    • findByC_Name

      public static Country findByC_Name(long companyId, String name) throws NoSuchCountryException
      Returns the country where companyId = ? and name = ? or throws a NoSuchCountryException if it could not be found.
      Parameters:
      companyId - the company ID
      name - the name
      Returns:
      the matching country
      Throws:
      NoSuchCountryException - if a matching country could not be found
      NoSuchCountryException
    • fetchByC_Name

      public static Country fetchByC_Name(long companyId, String name)
      Returns the country where companyId = ? and name = ? or returns null if it could not be found. Uses the finder cache.
      Parameters:
      companyId - the company ID
      name - the name
      Returns:
      the matching country, or null if a matching country could not be found
    • fetchByC_Name

      public static Country fetchByC_Name(long companyId, String name, boolean useFinderCache)
      Returns the country where companyId = ? and name = ? or returns null if it could not be found, optionally using the finder cache.
      Parameters:
      companyId - the company ID
      name - the name
      useFinderCache - whether to use the finder cache
      Returns:
      the matching country, or null if a matching country could not be found
    • removeByC_Name

      public static Country removeByC_Name(long companyId, String name) throws NoSuchCountryException
      Removes the country where companyId = ? and name = ? from the database.
      Parameters:
      companyId - the company ID
      name - the name
      Returns:
      the country that was removed
      Throws:
      NoSuchCountryException
    • countByC_Name

      public static int countByC_Name(long companyId, String name)
      Returns the number of countries where companyId = ? and name = ?.
      Parameters:
      companyId - the company ID
      name - the name
      Returns:
      the number of matching countries
    • findByC_Number

      public static Country findByC_Number(long companyId, String number) throws NoSuchCountryException
      Returns the country where companyId = ? and number = ? or throws a NoSuchCountryException if it could not be found.
      Parameters:
      companyId - the company ID
      number - the number
      Returns:
      the matching country
      Throws:
      NoSuchCountryException - if a matching country could not be found
      NoSuchCountryException
    • fetchByC_Number

      public static Country fetchByC_Number(long companyId, String number)
      Returns the country where companyId = ? and number = ? or returns null if it could not be found. Uses the finder cache.
      Parameters:
      companyId - the company ID
      number - the number
      Returns:
      the matching country, or null if a matching country could not be found
    • fetchByC_Number

      public static Country fetchByC_Number(long companyId, String number, boolean useFinderCache)
      Returns the country where companyId = ? and number = ? or returns null if it could not be found, optionally using the finder cache.
      Parameters:
      companyId - the company ID
      number - the number
      useFinderCache - whether to use the finder cache
      Returns:
      the matching country, or null if a matching country could not be found
    • removeByC_Number

      public static Country removeByC_Number(long companyId, String number) throws NoSuchCountryException
      Removes the country where companyId = ? and number = ? from the database.
      Parameters:
      companyId - the company ID
      number - the number
      Returns:
      the country that was removed
      Throws:
      NoSuchCountryException
    • countByC_Number

      public static int countByC_Number(long companyId, String number)
      Returns the number of countries where companyId = ? and number = ?.
      Parameters:
      companyId - the company ID
      number - the number
      Returns:
      the number of matching countries
    • findByC_A_B

      public static List<Country> findByC_A_B(long companyId, boolean active, boolean billingAllowed)
      Returns all the countries where companyId = ? and active = ? and billingAllowed = ?.
      Parameters:
      companyId - the company ID
      active - the active
      billingAllowed - the billing allowed
      Returns:
      the matching countries
    • findByC_A_B

      public static List<Country> findByC_A_B(long companyId, boolean active, boolean billingAllowed, int start, int end)
      Returns a range of all the countries where companyId = ? and active = ? and billingAllowed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      companyId - the company ID
      active - the active
      billingAllowed - the billing allowed
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      Returns:
      the range of matching countries
    • findByC_A_B

      public static List<Country> findByC_A_B(long companyId, boolean active, boolean billingAllowed, int start, int end, OrderByComparator<Country> orderByComparator)
      Returns an ordered range of all the countries where companyId = ? and active = ? and billingAllowed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      companyId - the company ID
      active - the active
      billingAllowed - the billing allowed
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching countries
    • findByC_A_B

      public static List<Country> findByC_A_B(long companyId, boolean active, boolean billingAllowed, int start, int end, OrderByComparator<Country> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the countries where companyId = ? and active = ? and billingAllowed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      companyId - the company ID
      active - the active
      billingAllowed - the billing allowed
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching countries
    • findByC_A_B_First

      public static Country findByC_A_B_First(long companyId, boolean active, boolean billingAllowed, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the first country in the ordered set where companyId = ? and active = ? and billingAllowed = ?.
      Parameters:
      companyId - the company ID
      active - the active
      billingAllowed - the billing allowed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching country
      Throws:
      NoSuchCountryException - if a matching country could not be found
      NoSuchCountryException
    • fetchByC_A_B_First

      public static Country fetchByC_A_B_First(long companyId, boolean active, boolean billingAllowed, OrderByComparator<Country> orderByComparator)
      Returns the first country in the ordered set where companyId = ? and active = ? and billingAllowed = ?.
      Parameters:
      companyId - the company ID
      active - the active
      billingAllowed - the billing allowed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching country, or null if a matching country could not be found
    • findByC_A_B_Last

      public static Country findByC_A_B_Last(long companyId, boolean active, boolean billingAllowed, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the last country in the ordered set where companyId = ? and active = ? and billingAllowed = ?.
      Parameters:
      companyId - the company ID
      active - the active
      billingAllowed - the billing allowed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching country
      Throws:
      NoSuchCountryException - if a matching country could not be found
      NoSuchCountryException
    • fetchByC_A_B_Last

      public static Country fetchByC_A_B_Last(long companyId, boolean active, boolean billingAllowed, OrderByComparator<Country> orderByComparator)
      Returns the last country in the ordered set where companyId = ? and active = ? and billingAllowed = ?.
      Parameters:
      companyId - the company ID
      active - the active
      billingAllowed - the billing allowed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching country, or null if a matching country could not be found
    • findByC_A_B_PrevAndNext

      public static Country[] findByC_A_B_PrevAndNext(long countryId, long companyId, boolean active, boolean billingAllowed, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the countries before and after the current country in the ordered set where companyId = ? and active = ? and billingAllowed = ?.
      Parameters:
      countryId - the primary key of the current country
      companyId - the company ID
      active - the active
      billingAllowed - the billing allowed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the previous, current, and next country
      Throws:
      NoSuchCountryException - if a country with the primary key could not be found
      NoSuchCountryException
    • removeByC_A_B

      public static void removeByC_A_B(long companyId, boolean active, boolean billingAllowed)
      Removes all the countries where companyId = ? and active = ? and billingAllowed = ? from the database.
      Parameters:
      companyId - the company ID
      active - the active
      billingAllowed - the billing allowed
    • countByC_A_B

      public static int countByC_A_B(long companyId, boolean active, boolean billingAllowed)
      Returns the number of countries where companyId = ? and active = ? and billingAllowed = ?.
      Parameters:
      companyId - the company ID
      active - the active
      billingAllowed - the billing allowed
      Returns:
      the number of matching countries
    • findByC_A_S

      public static List<Country> findByC_A_S(long companyId, boolean active, boolean shippingAllowed)
      Returns all the countries where companyId = ? and active = ? and shippingAllowed = ?.
      Parameters:
      companyId - the company ID
      active - the active
      shippingAllowed - the shipping allowed
      Returns:
      the matching countries
    • findByC_A_S

      public static List<Country> findByC_A_S(long companyId, boolean active, boolean shippingAllowed, int start, int end)
      Returns a range of all the countries where companyId = ? and active = ? and shippingAllowed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      companyId - the company ID
      active - the active
      shippingAllowed - the shipping allowed
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      Returns:
      the range of matching countries
    • findByC_A_S

      public static List<Country> findByC_A_S(long companyId, boolean active, boolean shippingAllowed, int start, int end, OrderByComparator<Country> orderByComparator)
      Returns an ordered range of all the countries where companyId = ? and active = ? and shippingAllowed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      companyId - the company ID
      active - the active
      shippingAllowed - the shipping allowed
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching countries
    • findByC_A_S

      public static List<Country> findByC_A_S(long companyId, boolean active, boolean shippingAllowed, int start, int end, OrderByComparator<Country> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the countries where companyId = ? and active = ? and shippingAllowed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      companyId - the company ID
      active - the active
      shippingAllowed - the shipping allowed
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching countries
    • findByC_A_S_First

      public static Country findByC_A_S_First(long companyId, boolean active, boolean shippingAllowed, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the first country in the ordered set where companyId = ? and active = ? and shippingAllowed = ?.
      Parameters:
      companyId - the company ID
      active - the active
      shippingAllowed - the shipping allowed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching country
      Throws:
      NoSuchCountryException - if a matching country could not be found
      NoSuchCountryException
    • fetchByC_A_S_First

      public static Country fetchByC_A_S_First(long companyId, boolean active, boolean shippingAllowed, OrderByComparator<Country> orderByComparator)
      Returns the first country in the ordered set where companyId = ? and active = ? and shippingAllowed = ?.
      Parameters:
      companyId - the company ID
      active - the active
      shippingAllowed - the shipping allowed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching country, or null if a matching country could not be found
    • findByC_A_S_Last

      public static Country findByC_A_S_Last(long companyId, boolean active, boolean shippingAllowed, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the last country in the ordered set where companyId = ? and active = ? and shippingAllowed = ?.
      Parameters:
      companyId - the company ID
      active - the active
      shippingAllowed - the shipping allowed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching country
      Throws:
      NoSuchCountryException - if a matching country could not be found
      NoSuchCountryException
    • fetchByC_A_S_Last

      public static Country fetchByC_A_S_Last(long companyId, boolean active, boolean shippingAllowed, OrderByComparator<Country> orderByComparator)
      Returns the last country in the ordered set where companyId = ? and active = ? and shippingAllowed = ?.
      Parameters:
      companyId - the company ID
      active - the active
      shippingAllowed - the shipping allowed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching country, or null if a matching country could not be found
    • findByC_A_S_PrevAndNext

      public static Country[] findByC_A_S_PrevAndNext(long countryId, long companyId, boolean active, boolean shippingAllowed, OrderByComparator<Country> orderByComparator) throws NoSuchCountryException
      Returns the countries before and after the current country in the ordered set where companyId = ? and active = ? and shippingAllowed = ?.
      Parameters:
      countryId - the primary key of the current country
      companyId - the company ID
      active - the active
      shippingAllowed - the shipping allowed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the previous, current, and next country
      Throws:
      NoSuchCountryException - if a country with the primary key could not be found
      NoSuchCountryException
    • removeByC_A_S

      public static void removeByC_A_S(long companyId, boolean active, boolean shippingAllowed)
      Removes all the countries where companyId = ? and active = ? and shippingAllowed = ? from the database.
      Parameters:
      companyId - the company ID
      active - the active
      shippingAllowed - the shipping allowed
    • countByC_A_S

      public static int countByC_A_S(long companyId, boolean active, boolean shippingAllowed)
      Returns the number of countries where companyId = ? and active = ? and shippingAllowed = ?.
      Parameters:
      companyId - the company ID
      active - the active
      shippingAllowed - the shipping allowed
      Returns:
      the number of matching countries
    • cacheResult

      public static void cacheResult(Country country)
      Caches the country in the entity cache if it is enabled.
      Parameters:
      country - the country
    • cacheResult

      public static void cacheResult(List<Country> countries)
      Caches the countries in the entity cache if it is enabled.
      Parameters:
      countries - the countries
    • create

      public static Country create(long countryId)
      Creates a new country with the primary key. Does not add the country to the database.
      Parameters:
      countryId - the primary key for the new country
      Returns:
      the new country
    • remove

      public static Country remove(long countryId) throws NoSuchCountryException
      Removes the country with the primary key from the database. Also notifies the appropriate model listeners.
      Parameters:
      countryId - the primary key of the country
      Returns:
      the country that was removed
      Throws:
      NoSuchCountryException - if a country with the primary key could not be found
      NoSuchCountryException
    • updateImpl

      public static Country updateImpl(Country country)
    • findByPrimaryKey

      public static Country findByPrimaryKey(long countryId) throws NoSuchCountryException
      Returns the country with the primary key or throws a NoSuchCountryException if it could not be found.
      Parameters:
      countryId - the primary key of the country
      Returns:
      the country
      Throws:
      NoSuchCountryException - if a country with the primary key could not be found
      NoSuchCountryException
    • fetchByPrimaryKey

      public static Country fetchByPrimaryKey(long countryId)
      Returns the country with the primary key or returns null if it could not be found.
      Parameters:
      countryId - the primary key of the country
      Returns:
      the country, or null if a country with the primary key could not be found
    • findAll

      public static List<Country> findAll()
      Returns all the countries.
      Returns:
      the countries
    • findAll

      public static List<Country> findAll(int start, int end)
      Returns a range of all the countries.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      Returns:
      the range of countries
    • findAll

      public static List<Country> findAll(int start, int end, OrderByComparator<Country> orderByComparator)
      Returns an ordered range of all the countries.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of countries
    • findAll

      public static List<Country> findAll(int start, int end, OrderByComparator<Country> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the countries.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from CountryModelImpl.

      Parameters:
      start - the lower bound of the range of countries
      end - the upper bound of the range of countries (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of countries
    • removeAll

      public static void removeAll()
      Removes all the countries from the database.
    • countAll

      public static int countAll()
      Returns the number of countries.
      Returns:
      the number of countries
    • getPersistence

      public static CountryPersistence getPersistence()
    • setPersistence

      public static void setPersistence(CountryPersistence persistence)