CountryUtil

java.lang.Object
- com.liferay.portal.kernel.service.persistence.CountryUtil

```
public class CountryUtil
extends java.lang.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:

CountryPersistence

Generated:

Constructor Summary

Constructors
Constructor and Description

CountryUtil()

Constructors
Constructor and Description
`CountryUtil()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`cacheResult(Country country)` Caches the country in the entity cache if it is enabled.
`static void`	`cacheResult(java.util.List<Country> countries)` Caches the countries in the entity cache if it is enabled.
`static void`	`clearCache()`
`static void`	`clearCache(Country country)`
`static int`	`countAll()` Returns the number of countries.
`static int`	`countByActive(boolean active)` Returns the number of countries where active = ?.
`static int`	`countByC_A_B(long companyId, boolean active, boolean billingAllowed)` Returns the number of countries where companyId = ? and active = ? and billingAllowed = ?.
`static int`	`countByC_A_S(long companyId, boolean active, boolean shippingAllowed)` Returns the number of countries where companyId = ? and active = ? and shippingAllowed = ?.
`static int`	`countByC_A2(long companyId, java.lang.String a2)` Returns the number of countries where companyId = ? and a2 = ?.
`static int`	`countByC_A3(long companyId, java.lang.String a3)` Returns the number of countries where companyId = ? and a3 = ?.
`static int`	`countByC_Active(long companyId, boolean active)` Returns the number of countries where companyId = ? and active = ?.
`static int`	`countByC_Name(long companyId, java.lang.String name)` Returns the number of countries where companyId = ? and name = ?.
`static int`	`countByC_Number(long companyId, java.lang.String number)` Returns the number of countries where companyId = ? and number = ?.
`static int`	`countByCompanyId(long companyId)` Returns the number of countries where companyId = ?.
`static int`	`countByUuid_C(java.lang.String uuid, long companyId)` Returns the number of countries where uuid = ? and companyId = ?.
`static int`	`countByUuid(java.lang.String uuid)` Returns the number of countries where uuid = ?.
`static long`	`countWithDynamicQuery(DynamicQuery dynamicQuery)`
`static Country`	`create(long countryId)` Creates a new country with the primary key.
`static Country`	`fetchByActive_First(boolean active, OrderByComparator<Country> orderByComparator)` Returns the first country in the ordered set where active = ?.
`static Country`	`fetchByActive_Last(boolean active, OrderByComparator<Country> orderByComparator)` Returns the last country in the ordered set where active = ?.
`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 = ?.
`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 = ?.
`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 = ?.
`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 = ?.
`static Country`	`fetchByC_A2(long companyId, java.lang.String a2)` Returns the country where companyId = ? and a2 = ? or returns `null` if it could not be found.
`static Country`	`fetchByC_A2(long companyId, java.lang.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.
`static Country`	`fetchByC_A3(long companyId, java.lang.String a3)` Returns the country where companyId = ? and a3 = ? or returns `null` if it could not be found.
`static Country`	`fetchByC_A3(long companyId, java.lang.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.
`static Country`	`fetchByC_Active_First(long companyId, boolean active, OrderByComparator<Country> orderByComparator)` Returns the first country in the ordered set where companyId = ? and active = ?.
`static Country`	`fetchByC_Active_Last(long companyId, boolean active, OrderByComparator<Country> orderByComparator)` Returns the last country in the ordered set where companyId = ? and active = ?.
`static Country`	`fetchByC_Name(long companyId, java.lang.String name)` Returns the country where companyId = ? and name = ? or returns `null` if it could not be found.
`static Country`	`fetchByC_Name(long companyId, java.lang.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.
`static Country`	`fetchByC_Number(long companyId, java.lang.String number)` Returns the country where companyId = ? and number = ? or returns `null` if it could not be found.
`static Country`	`fetchByC_Number(long companyId, java.lang.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.
`static Country`	`fetchByCompanyId_First(long companyId, OrderByComparator<Country> orderByComparator)` Returns the first country in the ordered set where companyId = ?.
`static Country`	`fetchByCompanyId_Last(long companyId, OrderByComparator<Country> orderByComparator)` Returns the last country in the ordered set where companyId = ?.
`static Country`	`fetchByPrimaryKey(long countryId)` Returns the country with the primary key or returns `null` if it could not be found.
`static java.util.Map<java.io.Serializable,Country>`	`fetchByPrimaryKeys(java.util.Set<java.io.Serializable> primaryKeys)`
`static Country`	`fetchByUuid_C_First(java.lang.String uuid, long companyId, OrderByComparator<Country> orderByComparator)` Returns the first country in the ordered set where uuid = ? and companyId = ?.
`static Country`	`fetchByUuid_C_Last(java.lang.String uuid, long companyId, OrderByComparator<Country> orderByComparator)` Returns the last country in the ordered set where uuid = ? and companyId = ?.
`static Country`	`fetchByUuid_First(java.lang.String uuid, OrderByComparator<Country> orderByComparator)` Returns the first country in the ordered set where uuid = ?.
`static Country`	`fetchByUuid_Last(java.lang.String uuid, OrderByComparator<Country> orderByComparator)` Returns the last country in the ordered set where uuid = ?.
`static java.util.List<Country>`	`findAll()` Returns all the countries.
`static java.util.List<Country>`	`findAll(int start, int end)` Returns a range of all the countries.
`static java.util.List<Country>`	`findAll(int start, int end, OrderByComparator<Country> orderByComparator)` Returns an ordered range of all the countries.
`static java.util.List<Country>`	`findAll(int start, int end, OrderByComparator<Country> orderByComparator, boolean useFinderCache)` Returns an ordered range of all the countries.
`static Country`	`findByActive_First(boolean active, OrderByComparator<Country> orderByComparator)` Returns the first country in the ordered set where active = ?.
`static Country`	`findByActive_Last(boolean active, OrderByComparator<Country> orderByComparator)` Returns the last country in the ordered set where active = ?.
`static Country[]`	`findByActive_PrevAndNext(long countryId, boolean active, OrderByComparator<Country> orderByComparator)` Returns the countries before and after the current country in the ordered set where active = ?.
`static java.util.List<Country>`	`findByActive(boolean active)` Returns all the countries where active = ?.
`static java.util.List<Country>`	`findByActive(boolean active, int start, int end)` Returns a range of all the countries where active = ?.
`static java.util.List<Country>`	`findByActive(boolean active, int start, int end, OrderByComparator<Country> orderByComparator)` Returns an ordered range of all the countries where active = ?.
`static java.util.List<Country>`	`findByActive(boolean active, int start, int end, OrderByComparator<Country> orderByComparator, boolean useFinderCache)` Returns an ordered range of all the countries where active = ?.
`static Country`	`findByC_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 = ?.
`static Country`	`findByC_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 = ?.
`static Country[]`	`findByC_A_B_PrevAndNext(long countryId, long companyId, boolean active, boolean billingAllowed, OrderByComparator<Country> orderByComparator)` Returns the countries before and after the current country in the ordered set where companyId = ? and active = ? and billingAllowed = ?.
`static java.util.List<Country>`	`findByC_A_B(long companyId, boolean active, boolean billingAllowed)` Returns all the countries where companyId = ? and active = ? and billingAllowed = ?.
`static java.util.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 = ?.
`static java.util.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 = ?.
`static java.util.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 = ?.
`static Country`	`findByC_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 = ?.
`static Country`	`findByC_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 = ?.
`static Country[]`	`findByC_A_S_PrevAndNext(long countryId, long companyId, boolean active, boolean shippingAllowed, OrderByComparator<Country> orderByComparator)` Returns the countries before and after the current country in the ordered set where companyId = ? and active = ? and shippingAllowed = ?.
`static java.util.List<Country>`	`findByC_A_S(long companyId, boolean active, boolean shippingAllowed)` Returns all the countries where companyId = ? and active = ? and shippingAllowed = ?.
`static java.util.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 = ?.
`static java.util.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 = ?.
`static java.util.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 = ?.
`static Country`	`findByC_A2(long companyId, java.lang.String a2)` Returns the country where companyId = ? and a2 = ? or throws a `NoSuchCountryException` if it could not be found.
`static Country`	`findByC_A3(long companyId, java.lang.String a3)` Returns the country where companyId = ? and a3 = ? or throws a `NoSuchCountryException` if it could not be found.
`static Country`	`findByC_Active_First(long companyId, boolean active, OrderByComparator<Country> orderByComparator)` Returns the first country in the ordered set where companyId = ? and active = ?.
`static Country`	`findByC_Active_Last(long companyId, boolean active, OrderByComparator<Country> orderByComparator)` Returns the last country in the ordered set where companyId = ? and active = ?.
`static Country[]`	`findByC_Active_PrevAndNext(long countryId, long companyId, boolean active, OrderByComparator<Country> orderByComparator)` Returns the countries before and after the current country in the ordered set where companyId = ? and active = ?.
`static java.util.List<Country>`	`findByC_Active(long companyId, boolean active)` Returns all the countries where companyId = ? and active = ?.
`static java.util.List<Country>`	`findByC_Active(long companyId, boolean active, int start, int end)` Returns a range of all the countries where companyId = ? and active = ?.
`static java.util.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 = ?.
`static java.util.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 = ?.
`static Country`	`findByC_Name(long companyId, java.lang.String name)` Returns the country where companyId = ? and name = ? or throws a `NoSuchCountryException` if it could not be found.
`static Country`	`findByC_Number(long companyId, java.lang.String number)` Returns the country where companyId = ? and number = ? or throws a `NoSuchCountryException` if it could not be found.
`static Country`	`findByCompanyId_First(long companyId, OrderByComparator<Country> orderByComparator)` Returns the first country in the ordered set where companyId = ?.
`static Country`	`findByCompanyId_Last(long companyId, OrderByComparator<Country> orderByComparator)` Returns the last country in the ordered set where companyId = ?.
`static Country[]`	`findByCompanyId_PrevAndNext(long countryId, long companyId, OrderByComparator<Country> orderByComparator)` Returns the countries before and after the current country in the ordered set where companyId = ?.
`static java.util.List<Country>`	`findByCompanyId(long companyId)` Returns all the countries where companyId = ?.
`static java.util.List<Country>`	`findByCompanyId(long companyId, int start, int end)` Returns a range of all the countries where companyId = ?.
`static java.util.List<Country>`	`findByCompanyId(long companyId, int start, int end, OrderByComparator<Country> orderByComparator)` Returns an ordered range of all the countries where companyId = ?.
`static java.util.List<Country>`	`findByCompanyId(long companyId, int start, int end, OrderByComparator<Country> orderByComparator, boolean useFinderCache)` Returns an ordered range of all the countries where companyId = ?.
`static Country`	`findByPrimaryKey(long countryId)` Returns the country with the primary key or throws a `NoSuchCountryException` if it could not be found.
`static Country`	`findByUuid_C_First(java.lang.String uuid, long companyId, OrderByComparator<Country> orderByComparator)` Returns the first country in the ordered set where uuid = ? and companyId = ?.
`static Country`	`findByUuid_C_Last(java.lang.String uuid, long companyId, OrderByComparator<Country> orderByComparator)` Returns the last country in the ordered set where uuid = ? and companyId = ?.
`static Country[]`	`findByUuid_C_PrevAndNext(long countryId, java.lang.String uuid, long companyId, OrderByComparator<Country> orderByComparator)` Returns the countries before and after the current country in the ordered set where uuid = ? and companyId = ?.
`static java.util.List<Country>`	`findByUuid_C(java.lang.String uuid, long companyId)` Returns all the countries where uuid = ? and companyId = ?.
`static java.util.List<Country>`	`findByUuid_C(java.lang.String uuid, long companyId, int start, int end)` Returns a range of all the countries where uuid = ? and companyId = ?.
`static java.util.List<Country>`	`findByUuid_C(java.lang.String uuid, long companyId, int start, int end, OrderByComparator<Country> orderByComparator)` Returns an ordered range of all the countries where uuid = ? and companyId = ?.
`static java.util.List<Country>`	`findByUuid_C(java.lang.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 = ?.
`static Country`	`findByUuid_First(java.lang.String uuid, OrderByComparator<Country> orderByComparator)` Returns the first country in the ordered set where uuid = ?.
`static Country`	`findByUuid_Last(java.lang.String uuid, OrderByComparator<Country> orderByComparator)` Returns the last country in the ordered set where uuid = ?.
`static Country[]`	`findByUuid_PrevAndNext(long countryId, java.lang.String uuid, OrderByComparator<Country> orderByComparator)` Returns the countries before and after the current country in the ordered set where uuid = ?.
`static java.util.List<Country>`	`findByUuid(java.lang.String uuid)` Returns all the countries where uuid = ?.
`static java.util.List<Country>`	`findByUuid(java.lang.String uuid, int start, int end)` Returns a range of all the countries where uuid = ?.
`static java.util.List<Country>`	`findByUuid(java.lang.String uuid, int start, int end, OrderByComparator<Country> orderByComparator)` Returns an ordered range of all the countries where uuid = ?.
`static java.util.List<Country>`	`findByUuid(java.lang.String uuid, int start, int end, OrderByComparator<Country> orderByComparator, boolean useFinderCache)` Returns an ordered range of all the countries where uuid = ?.
`static java.util.List<Country>`	`findWithDynamicQuery(DynamicQuery dynamicQuery)`
`static java.util.List<Country>`	`findWithDynamicQuery(DynamicQuery dynamicQuery, int start, int end)`
`static java.util.List<Country>`	`findWithDynamicQuery(DynamicQuery dynamicQuery, int start, int end, OrderByComparator<Country> orderByComparator)`
`static CountryPersistence`	`getPersistence()`
`static Country`	`remove(long countryId)` Removes the country with the primary key from the database.
`static void`	`removeAll()` Removes all the countries from the database.
`static void`	`removeByActive(boolean active)` Removes all the countries where active = ? from the database.
`static void`	`removeByC_A_B(long companyId, boolean active, boolean billingAllowed)` Removes all the countries where companyId = ? and active = ? and billingAllowed = ? from the database.
`static void`	`removeByC_A_S(long companyId, boolean active, boolean shippingAllowed)` Removes all the countries where companyId = ? and active = ? and shippingAllowed = ? from the database.
`static Country`	`removeByC_A2(long companyId, java.lang.String a2)` Removes the country where companyId = ? and a2 = ? from the database.
`static Country`	`removeByC_A3(long companyId, java.lang.String a3)` Removes the country where companyId = ? and a3 = ? from the database.
`static void`	`removeByC_Active(long companyId, boolean active)` Removes all the countries where companyId = ? and active = ? from the database.
`static Country`	`removeByC_Name(long companyId, java.lang.String name)` Removes the country where companyId = ? and name = ? from the database.
`static Country`	`removeByC_Number(long companyId, java.lang.String number)` Removes the country where companyId = ? and number = ? from the database.
`static void`	`removeByCompanyId(long companyId)` Removes all the countries where companyId = ? from the database.
`static void`	`removeByUuid_C(java.lang.String uuid, long companyId)` Removes all the countries where uuid = ? and companyId = ? from the database.
`static void`	`removeByUuid(java.lang.String uuid)` Removes all the countries where uuid = ? from the database.
`static void`	`setPersistence(CountryPersistence persistence)`
`static Country`	`update(Country country)`
`static Country`	`update(Country country, ServiceContext serviceContext)`
`static Country`	`updateImpl(Country country)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - CountryUtil
```
public CountryUtil()
```
- Method Detail
  - clearCache
```
public static void clearCache()
```
    See Also:
    
    BasePersistence.clearCache()
  - clearCache
```
public static void clearCache(Country country)
```
    See Also:
    
    BasePersistence.clearCache(com.liferay.portal.kernel.model.BaseModel)
  - countWithDynamicQuery
```
public static long countWithDynamicQuery(DynamicQuery dynamicQuery)
```
    See Also:
    
    BasePersistence.countWithDynamicQuery(DynamicQuery)
  - fetchByPrimaryKeys
```
public static java.util.Map<java.io.Serializable,Country> fetchByPrimaryKeys(java.util.Set<java.io.Serializable> primaryKeys)
```
    See Also:
    
    BasePersistence.fetchByPrimaryKeys(Set)
  - findWithDynamicQuery
```
public static java.util.List<Country> findWithDynamicQuery(DynamicQuery dynamicQuery)
```
    See Also:
    
    BasePersistence.findWithDynamicQuery(DynamicQuery)
  - findWithDynamicQuery
```
public static java.util.List<Country> findWithDynamicQuery(DynamicQuery dynamicQuery,
                                                           int start,
                                                           int end)
```
    See Also:
    
    BasePersistence.findWithDynamicQuery(DynamicQuery, int, int)
  - findWithDynamicQuery
```
public static java.util.List<Country> findWithDynamicQuery(DynamicQuery dynamicQuery,
                                                           int start,
                                                           int end,
                                                           OrderByComparator<Country> orderByComparator)
```
    See Also:
    
    BasePersistence.findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
  - update
```
public static Country update(Country country)
```
    See Also:
    
    BasePersistence.update(com.liferay.portal.kernel.model.BaseModel)
  - update
```
public static Country update(Country country,
                             ServiceContext serviceContext)
```
    See Also:
    
    BasePersistence.update(com.liferay.portal.kernel.model.BaseModel, ServiceContext)
  - findByUuid
```
public static java.util.List<Country> findByUuid(java.lang.String uuid)
```
    Returns all the countries where uuid = ?.
    
    Parameters:
    
    uuid - the uuid
    
    Returns:
    
    the matching countries
  - findByUuid
```
public static java.util.List<Country> findByUuid(java.lang.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 java.util.List<Country> findByUuid(java.lang.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 java.util.List<Country> findByUuid(java.lang.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(java.lang.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
```
public static Country fetchByUuid_First(java.lang.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(java.lang.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
```
public static Country fetchByUuid_Last(java.lang.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,
                                               java.lang.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
```
public static void removeByUuid(java.lang.String uuid)
```
    Removes all the countries where uuid = ? from the database.
    
    Parameters:
    
    uuid - the uuid
  - countByUuid
```
public static int countByUuid(java.lang.String uuid)
```
    Returns the number of countries where uuid = ?.
    
    Parameters:
    
    uuid - the uuid
    
    Returns:
    
    the number of matching countries
  - findByUuid_C
```
public static java.util.List<Country> findByUuid_C(java.lang.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 java.util.List<Country> findByUuid_C(java.lang.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 java.util.List<Country> findByUuid_C(java.lang.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 java.util.List<Country> findByUuid_C(java.lang.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(java.lang.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
```
public static Country fetchByUuid_C_First(java.lang.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(java.lang.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
```
public static Country fetchByUuid_C_Last(java.lang.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,
                                                 java.lang.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
```
public static void removeByUuid_C(java.lang.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(java.lang.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 java.util.List<Country> findByCompanyId(long companyId)
```
    Returns all the countries where companyId = ?.
    
    Parameters:
    
    companyId - the company ID
    
    Returns:
    
    the matching countries
  - findByCompanyId
```
public static java.util.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 java.util.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 java.util.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
  - 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
  - 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
  - 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 java.util.List<Country> findByActive(boolean active)
```
    Returns all the countries where active = ?.
    
    Parameters:
    
    active - the active
    
    Returns:
    
    the matching countries
  - findByActive
```
public static java.util.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 java.util.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 java.util.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
  - 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
  - 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
  - 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,
                                 java.lang.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
```
public static Country fetchByC_A2(long companyId,
                                  java.lang.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,
                                  java.lang.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,
                                   java.lang.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,
                              java.lang.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,
                                 java.lang.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
```
public static Country fetchByC_A3(long companyId,
                                  java.lang.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,
                                  java.lang.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,
                                   java.lang.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,
                              java.lang.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 java.util.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 java.util.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 java.util.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 java.util.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
  - 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
  - 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
  - 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,
                                   java.lang.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
```
public static Country fetchByC_Name(long companyId,
                                    java.lang.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,
                                    java.lang.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,
                                     java.lang.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,
                                java.lang.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,
                                     java.lang.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
```
public static Country fetchByC_Number(long companyId,
                                      java.lang.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,
                                      java.lang.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,
                                       java.lang.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,
                                  java.lang.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 java.util.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 java.util.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 java.util.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 java.util.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
  - 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
  - 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
  - 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 java.util.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 java.util.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 java.util.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 java.util.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
  - 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
  - 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
  - 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(java.util.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
  - 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
  - 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 java.util.List<Country> findAll()
```
    Returns all the countries.
    
    Returns:
    
    the countries
  - findAll
```
public static java.util.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 java.util.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 java.util.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)
```

Class CountryUtil

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

CountryUtil

Method Detail

clearCache

clearCache

countWithDynamicQuery

fetchByPrimaryKeys

findWithDynamicQuery

findWithDynamicQuery

findWithDynamicQuery

update

update

findByUuid

findByUuid

findByUuid

findByUuid

findByUuid_First

fetchByUuid_First

findByUuid_Last

fetchByUuid_Last

findByUuid_PrevAndNext

removeByUuid

countByUuid

findByUuid_C

findByUuid_C

findByUuid_C

findByUuid_C

findByUuid_C_First

fetchByUuid_C_First

findByUuid_C_Last

fetchByUuid_C_Last

findByUuid_C_PrevAndNext

removeByUuid_C

countByUuid_C

findByCompanyId

findByCompanyId

findByCompanyId

findByCompanyId

findByCompanyId_First

fetchByCompanyId_First

findByCompanyId_Last

fetchByCompanyId_Last

findByCompanyId_PrevAndNext

removeByCompanyId

countByCompanyId

findByActive

findByActive

findByActive

findByActive

findByActive_First

fetchByActive_First

findByActive_Last

fetchByActive_Last

findByActive_PrevAndNext

removeByActive

countByActive

findByC_A2

fetchByC_A2

fetchByC_A2

removeByC_A2

countByC_A2

findByC_A3

fetchByC_A3

fetchByC_A3

removeByC_A3

countByC_A3

findByC_Active

findByC_Active

findByC_Active

findByC_Active

findByC_Active_First

fetchByC_Active_First

findByC_Active_Last

fetchByC_Active_Last

findByC_Active_PrevAndNext

removeByC_Active