Interface CountryPersistence

All Superinterfaces:
BasePersistence<Country>, CTPersistence<Country>

@ProviderType public interface CountryPersistence extends BasePersistence<Country>, CTPersistence<Country>
The persistence interface for the country service.

Caching information and settings can be found in portal.properties

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

    • findByUuid

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

      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

      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

      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

      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
    • fetchByUuid_First

      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

      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
    • fetchByUuid_Last

      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

      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
    • removeByUuid

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

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

      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

      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

      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

      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

      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
    • fetchByUuid_C_First

      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

      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
    • fetchByUuid_C_Last

      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

      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
    • removeByUuid_C

      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

      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

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

      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

      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

      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

      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
    • fetchByCompanyId_First

      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

      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
    • fetchByCompanyId_Last

      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

      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
    • removeByCompanyId

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

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

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

      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

      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

      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

      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
    • fetchByActive_First

      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

      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
    • fetchByActive_Last

      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

      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
    • removeByActive

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

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

      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
    • fetchByC_A2

      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

      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

      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

      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

      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
    • fetchByC_A3

      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

      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

      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

      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

      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

      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

      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

      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

      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
    • fetchByC_Active_First

      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

      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
    • fetchByC_Active_Last

      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

      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
    • removeByC_Active

      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

      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

      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
    • fetchByC_Name

      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

      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

      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

      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

      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
    • fetchByC_Number

      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

      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

      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

      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

      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

      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

      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

      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

      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
    • fetchByC_A_B_First

      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

      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
    • fetchByC_A_B_Last

      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

      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
    • removeByC_A_B

      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

      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

      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

      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

      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

      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

      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
    • fetchByC_A_S_First

      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

      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
    • fetchByC_A_S_Last

      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

      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
    • removeByC_A_S

      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

      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

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

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

      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

      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
    • updateImpl

      Country updateImpl(Country country)
    • findByPrimaryKey

      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
    • fetchByPrimaryKey

      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

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

      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

      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

      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

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

      int countAll()
      Returns the number of countries.
      Returns:
      the number of countries