Interface Delegator

All Known Implementing Classes:
GenericDelegator

public interface Delegator
  • Method Details

    • clearAllCacheLinesByDummyPK

      void clearAllCacheLinesByDummyPK(Collection<GenericPK> dummyPKs)
    • clearAllCacheLinesByValue

      void clearAllCacheLinesByValue(Collection<GenericValue> values)
    • clearAllCaches

      void clearAllCaches()
      This method is a shortcut to completely clear all entity engine caches. For performance reasons this should not be called very often.
    • clearAllCaches

      void clearAllCaches(boolean distribute)
    • clearCacheLine

      void clearCacheLine(GenericPK primaryKey)
      Remove a CACHED Generic Entity from the cache by its primary key, does NOT check to see if the passed GenericPK is a complete primary key. Also tries to clear the corresponding all cache entry.
      Parameters:
      primaryKey - The primary key to clear by.
    • clearCacheLine

      void clearCacheLine(GenericPK primaryKey, boolean distribute)
    • clearCacheLine

      void clearCacheLine(GenericValue value)
      Remove a CACHED GenericValue from as many caches as it can. Automatically tries to remove entries from the all cache, the by primary key cache, and the by and cache. This is the ONLY method that tries to clear automatically from the by and cache.
      Parameters:
      value - The GenericValue to clear by.
    • clearCacheLine

      void clearCacheLine(GenericValue value, boolean distribute)
    • clearCacheLine

      void clearCacheLine(String entityName)
      Remove all CACHED Generic Entity (List) from the cache
      Parameters:
      entityName - The Name of the Entity as defined in the entity XML file
    • clearCacheLine

      void clearCacheLine(String entityName, Map<String,? extends Object> fields)
      Remove a CACHED Generic Entity (List) from the cache, either a PK, ByAnd, or All
      Parameters:
      entityName - The Name of the Entity as defined in the entity XML file
      fields - The fields of the named entity to query by with their corresponding values
    • clearCacheLine

      void clearCacheLine(String entityName, Object... fields)
      Remove a CACHED Generic Entity (List) from the cache, either a PK, ByAnd, or All
      Parameters:
      entityName - The Name of the Entity as defined in the entity XML file
      fields - The fields of the named entity to query by with their corresponding values
    • clearCacheLineByCondition

      void clearCacheLineByCondition(String entityName, EntityCondition condition)
    • clearCacheLineByCondition

      void clearCacheLineByCondition(String entityName, EntityCondition condition, boolean distribute)
    • clearCacheLineFlexible

      void clearCacheLineFlexible(GenericEntity dummyPK)
      Remove a CACHED Generic Entity from the cache by its primary key. Checks to see if the passed GenericPK is a complete primary key, if it is then the cache line will be removed from the primaryKeyCache; if it is NOT a complete primary key it will remove the cache line from the andCache. If the fields map is empty, then the allCache for the entity will be cleared.
      Parameters:
      dummyPK - The dummy primary key to clear by.
    • clearCacheLineFlexible

      void clearCacheLineFlexible(GenericEntity dummyPK, boolean distribute)
    • cloneDelegator

      Delegator cloneDelegator()
    • cloneDelegator

      Delegator cloneDelegator(String delegatorName)
    • create

      GenericValue create(GenericPK primaryKey) throws GenericEntityException
      Creates a Entity in the form of a GenericValue and write it to the datasource
      Parameters:
      primaryKey - The GenericPK to create a value in the datasource from
      Returns:
      GenericValue instance containing the new instance
      Throws:
      GenericEntityException
    • create

      Creates a Entity in the form of a GenericValue and write it to the datasource
      Parameters:
      value - The GenericValue to create a value in the datasource from
      Returns:
      GenericValue instance containing the new instance
      Throws:
      GenericEntityException
    • create

      GenericValue create(String entityName, Map<String,? extends Object> fields) throws GenericEntityException
      Creates a Entity in the form of a GenericValue and write it to the database
      Returns:
      GenericValue instance containing the new instance
      Throws:
      GenericEntityException
    • create

      GenericValue create(String entityName, Object... fields) throws GenericEntityException
      Creates a Entity in the form of a GenericValue and write it to the database
      Returns:
      GenericValue instance containing the new instance
      Throws:
      GenericEntityException
    • createOrStore

      GenericValue createOrStore(GenericValue value) throws GenericEntityException
      Creates or stores an Entity
      Parameters:
      value - The GenericValue instance containing the new or existing instance
      Returns:
      GenericValue instance containing the new or updated instance
      Throws:
      GenericEntityException
    • createSetNextSeqId

      GenericValue createSetNextSeqId(GenericValue value) throws GenericEntityException
      Sets the sequenced ID (for entity with one primary key field ONLY), and then does a create in the database as normal. The reason to do it this way is that it will retry and fix the sequence if somehow the sequencer is in a bad state and returning a value that already exists.
      Parameters:
      value - The GenericValue to create a value in the datasource from
      Returns:
      GenericValue instance containing the new instance
      Throws:
      GenericEntityException
    • createSingle

      GenericValue createSingle(String entityName, Object singlePkValue) throws GenericEntityException
      Creates a Entity in the form of a GenericValue and write it to the database
      Returns:
      GenericValue instance containing the new instance
      Throws:
      GenericEntityException
    • decryptFieldValue

      Object decryptFieldValue(String entityName, ModelField.EncryptMethod encryptMethod, String encValue) throws EntityCryptoException
      Throws:
      EntityCryptoException
    • encryptFieldValue

      Object encryptFieldValue(String entityName, ModelField.EncryptMethod encryptMethod, Object fieldValue) throws EntityCryptoException
      Throws:
      EntityCryptoException
    • find

      EntityListIterator find(String entityName, EntityCondition whereEntityCondition, EntityCondition havingEntityCondition, Set<String> fieldsToSelect, List<String> orderBy, EntityFindOptions findOptions) throws GenericEntityException
      Finds GenericValues by the conditions specified in the EntityCondition object, the the EntityCondition javadoc for more details.
      Parameters:
      entityName - The name of the Entity as defined in the entity XML file
      whereEntityCondition - The EntityCondition object that specifies how to constrain this query before any groupings are done (if this is a view entity with group-by aliases)
      havingEntityCondition - The EntityCondition object that specifies how to constrain this query after any groupings are done (if this is a view entity with group-by aliases)
      fieldsToSelect - The fields of the named entity to get from the database; if empty or null all fields will be retreived
      orderBy - The fields of the named entity to order the query by; optionally add a " ASC" for ascending or " DESC" for descending
      findOptions - An instance of EntityFindOptions that specifies advanced query options. See the EntityFindOptions JavaDoc for more details.
      Returns:
      EntityListIterator representing the result of the query: NOTE THAT THIS MUST BE CLOSED (preferably in a finally block) WHEN YOU ARE DONE WITH IT, AND DON'T LEAVE IT OPEN TOO LONG BEACUSE IT WILL MAINTAIN A DATABASE CONNECTION.
      Throws:
      GenericEntityException
    • findAll

      List<GenericValue> findAll(String entityName, boolean useCache) throws GenericEntityException
      Finds all Generic entities
      Parameters:
      entityName - The Name of the Entity as defined in the entity XML file
      useCache - Whether to cache the results
      Returns:
      List containing all Generic entities
      Throws:
      GenericEntityException
    • findByAnd

      List<GenericValue> findByAnd(String entityName, Map<String,? extends Object> fields, List<String> orderBy, boolean useCache) throws GenericEntityException
      Finds Generic Entity records by all of the specified fields (ie: combined using AND), looking first in the cache; uses orderBy for lookup, but only keys results on the entityName and fields
      Parameters:
      entityName - The Name of the Entity as defined in the entity XML file
      fields - The fields of the named entity to query by with their corresponding values
      orderBy - The fields of the named entity to order the query by; optionally add a " ASC" for ascending or " DESC" for descending
      useCache - Whether to cache the results
      Returns:
      List of GenericValue instances that match the query
      Throws:
      GenericEntityException
    • findByPrimaryKeyPartial

      GenericValue findByPrimaryKeyPartial(GenericPK primaryKey, Set<String> keys) throws GenericEntityException
      Find a Generic Entity by its Primary Key and only returns the values requested by the passed keys (names).
      Parameters:
      primaryKey - The primary key to find by.
      keys - The keys, or names, of the values to retrieve; only these values will be retrieved
      Returns:
      The GenericValue corresponding to the primaryKey
      Throws:
      GenericEntityException
    • findCountByCondition

      long findCountByCondition(String entityName, EntityCondition whereEntityCondition, EntityCondition havingEntityCondition, EntityFindOptions findOptions) throws GenericEntityException
      Gets the hit count of GenericValues for the given EntityCondition objects.
      Parameters:
      entityName -
      whereEntityCondition -
      havingEntityCondition -
      findOptions -
      Returns:
      long value with hit count
      Throws:
      GenericEntityException
    • findCountByCondition

      long findCountByCondition(String entityName, EntityCondition whereEntityCondition, Set<String> fieldsToSelect, EntityCondition havingEntityCondition, EntityFindOptions findOptions) throws GenericEntityException
      Gets the hit count of GenericValues for the given EntityCondition objects.
      Parameters:
      entityName -
      whereEntityCondition -
      fieldsToSelect -
      havingEntityCondition -
      findOptions -
      Returns:
      long value with hit count
      Throws:
      GenericEntityException
    • findList

      List<GenericValue> findList(String entityName, EntityCondition entityCondition, Set<String> fieldsToSelect, List<String> orderBy, EntityFindOptions findOptions, boolean useCache) throws GenericEntityException
      Finds GenericValues by the conditions specified in the EntityCondition object, the the EntityCondition javadoc for more details.
      Parameters:
      entityName - The name of the Entity as defined in the entity XML file
      entityCondition - The EntityCondition object that specifies how to constrain this query before any groupings are done (if this is a view entity with group-by aliases)
      fieldsToSelect - The fields of the named entity to get from the database; if empty or null all fields will be retrieved
      orderBy - The fields of the named entity to order the query by; optionally add a " ASC" for ascending or " DESC" for descending
      findOptions - An instance of EntityFindOptions that specifies advanced query options. See the EntityFindOptions JavaDoc for more details.
      Returns:
      List of GenericValue objects representing the result
      Throws:
      GenericEntityException
    • findList

      List<GenericValue> findList(String entityName, EntityCondition entityCondition, EntityCondition havingEntityCondition, Set<String> fieldsToSelect, List<String> orderBy, EntityFindOptions findOptions, boolean useCache) throws GenericEntityException
      Finds GenericValues by the conditions specified in the EntityCondition object, the the EntityCondition javadoc for more details.
      Parameters:
      entityName - The name of the Entity as defined in the entity XML file
      entityCondition - The EntityCondition object that specifies how to constrain this query before any groupings are done (if this is a view entity with group-by aliases)
      havingEntityCondition - The EntityCondition object that specifies how to constrain this query after any groupings are done (if this is a view entity with group-by aliases)
      fieldsToSelect - The fields of the named entity to get from the database; if empty or null all fields will be retrieved
      orderBy - The fields of the named entity to order the query by; optionally add a " ASC" for ascending or " DESC" for descending
      findOptions - An instance of EntityFindOptions that specifies advanced query options. See the EntityFindOptions JavaDoc for more details.
      Returns:
      List of GenericValue objects representing the result
      Throws:
      GenericEntityException
    • findListIteratorByCondition

      EntityListIterator findListIteratorByCondition(DynamicViewEntity dynamicViewEntity, EntityCondition whereEntityCondition, EntityCondition havingEntityCondition, Collection<String> fieldsToSelect, List<String> orderBy, EntityFindOptions findOptions) throws GenericEntityException
      Finds GenericValues by the conditions specified in the EntityCondition object, the the EntityCondition javadoc for more details.
      Parameters:
      dynamicViewEntity - The DynamicViewEntity to use for the entity model for this query; generally created on the fly for limited use
      whereEntityCondition - The EntityCondition object that specifies how to constrain this query before any groupings are done (if this is a view entity with group-by aliases)
      havingEntityCondition - The EntityCondition object that specifies how to constrain this query after any groupings are done (if this is a view entity with group-by aliases)
      fieldsToSelect - The fields of the named entity to get from the database; if empty or null all fields will be retreived
      orderBy - The fields of the named entity to order the query by; optionally add a " ASC" for ascending or " DESC" for descending
      findOptions - An instance of EntityFindOptions that specifies advanced query options. See the EntityFindOptions JavaDoc for more details.
      Returns:
      EntityListIterator representing the result of the query: NOTE THAT THIS MUST BE CLOSED WHEN YOU ARE DONE WITH IT, AND DON'T LEAVE IT OPEN TOO LONG BEACUSE IT WILL MAINTAIN A DATABASE CONNECTION.
      Throws:
      GenericEntityException
    • findOne

      GenericValue findOne(String entityName, boolean useCache, Object... fields) throws GenericEntityException
      Find a Generic Entity by its primary key.
      Parameters:
      entityName - The Name of the Entity as defined in the entity XML file
      useCache - Retrieve the Generic Entity from the cache when true
      fields - The fields of the named entity to query by with their corresponding values
      Returns:
      The Generic Entity corresponding to the primary key
      Throws:
      GenericEntityException
    • findOne

      GenericValue findOne(String entityName, Map<String,? extends Object> fields, boolean useCache) throws GenericEntityException
      Find a Generic Entity by its Primary Key
      Parameters:
      entityName - The Name of the Entity as defined in the entity XML file
      fields - The fields of the named entity to query by with their corresponding values
      Returns:
      The GenericValue corresponding to the primaryKey
      Throws:
      GenericEntityException
    • getCache

      Cache getCache()
    • getCurrentSessionIdentifier

      String getCurrentSessionIdentifier()
    • getCurrentUserIdentifier

      String getCurrentUserIdentifier()
    • getDelegatorName

      String getDelegatorName()
    • getDelegatorBaseName

      String getDelegatorBaseName()
    • getDelegatorTenantId

      String getDelegatorTenantId()
    • getEntityEcaHandler

      <T> EntityEcaHandler<T> getEntityEcaHandler()
    • getEntityFieldType

      ModelFieldType getEntityFieldType(ModelEntity entity, String type) throws GenericEntityException
      Gets a field type instance by name from the helper that corresponds to the specified entity
      Parameters:
      entity - The entity
      type - The name of the type
      Returns:
      ModelFieldType instance for the named type from the helper that corresponds to the specified entity
      Throws:
      GenericEntityException
    • getEntityGroupName

      String getEntityGroupName(String entityName)
      Gets the helper name that corresponds to this delegator and the specified entityName
      Parameters:
      entityName - The name of the entity to get the helper for
      Returns:
      String with the helper name that corresponds to this delegator and the specified entityName
    • getEntityHelper

      GenericHelper getEntityHelper(ModelEntity entity) throws GenericEntityException
      Gets the an instance of helper that corresponds to this delegator and the specified entity
      Parameters:
      entity - The entity to get the helper for
      Returns:
      GenericHelper that corresponds to this delegator and the specified entity
      Throws:
      GenericEntityException
    • getEntityHelper

      GenericHelper getEntityHelper(String entityName) throws GenericEntityException
      Gets the an instance of helper that corresponds to this delegator and the specified entityName
      Parameters:
      entityName - The name of the entity to get the helper for
      Returns:
      GenericHelper that corresponds to this delegator and the specified entityName
      Throws:
      GenericEntityException
    • getEntityHelperName

      String getEntityHelperName(ModelEntity entity)
      Gets the helper name that corresponds to this delegator and the specified entity
      Parameters:
      entity - The entity to get the helper for
      Returns:
      String with the helper name that corresponds to this delegator and the specified entity
    • getEntityHelperName

      String getEntityHelperName(String entityName)
      Gets the helper name that corresponds to this delegator and the specified entityName
      Parameters:
      entityName - The name of the entity to get the helper name for
      Returns:
      String with the helper name that corresponds to this delegator and the specified entityName
    • getFromPrimaryKeyCache

      GenericValue getFromPrimaryKeyCache(GenericPK primaryKey)
    • getGroupHelperName

      String getGroupHelperName(String groupName)
      Gets the helper name that corresponds to this delegator and the specified entityName
      Parameters:
      groupName - The name of the group to get the helper name for
      Returns:
      String with the helper name that corresponds to this delegator and the specified entityName
    • getGroupHelperInfo

      GenericHelperInfo getGroupHelperInfo(String entityGroupName)
    • getModelEntity

      ModelEntity getModelEntity(String entityName)
      Gets the instance of ModelEntity that corresponds to this delegator and the specified entityName
      Parameters:
      entityName - The name of the entity to get
      Returns:
      ModelEntity that corresponds to this delegator and the specified entityName
    • getModelEntityMapByGroup

      Map<String,ModelEntity> getModelEntityMapByGroup(String groupName) throws GenericEntityException
      Gets a Map of entity name and entity model pairs that are in the named group
      Parameters:
      groupName - The name of the group
      Returns:
      Map of entityName String keys and ModelEntity instance values
      Throws:
      GenericEntityException
    • getModelFieldTypeReader

      ModelFieldTypeReader getModelFieldTypeReader(ModelEntity entity)
    • getModelGroupReader

      ModelGroupReader getModelGroupReader()
      Gets the instance of ModelGroupReader that corresponds to this delegator
      Returns:
      ModelGroupReader that corresponds to this delegator
    • getModelReader

      ModelReader getModelReader()
      Gets the instance of ModelReader that corresponds to this delegator
      Returns:
      ModelReader that corresponds to this delegator
    • getMultiRelation

      List<GenericValue> getMultiRelation(GenericValue value, String relationNameOne, String relationNameTwo, List<String> orderBy) throws GenericEntityException
      Get the named Related Entity for the GenericValue from the persistent store across another Relation. Helps to get related Values in a multi-to-multi relationship.
      Parameters:
      relationNameOne - String containing the relation name which is the combination of relation.title and relation.rel-entity-name as specified in the entity XML definition file, for first relation
      relationNameTwo - String containing the relation name for second relation
      value - GenericValue instance containing the entity
      orderBy - The fields of the named entity to order the query by; may be null; optionally add a " ASC" for ascending or " DESC" for descending
      Returns:
      List of GenericValue instances as specified in the relation definition
      Throws:
      GenericEntityException
    • getNextSeqId

      String getNextSeqId(String seqName)
      Get the next guaranteed unique seq id from the sequence with the given sequence name; if the named sequence doesn't exist, it will be created
      Parameters:
      seqName - The name of the sequence to get the next seq id from
      Returns:
      String with the next sequenced id for the given sequence name
    • getNextSeqId

      String getNextSeqId(String seqName, long staggerMax)
      Get the next guaranteed unique seq id from the sequence with the given sequence name; if the named sequence doesn't exist, it will be created
      Parameters:
      seqName - The name of the sequence to get the next seq id from
      staggerMax - The maximum amount to stagger the sequenced ID, if 1 the sequence will be incremented by 1, otherwise the current sequence ID will be incremented by a value between 1 and staggerMax
      Returns:
      Long with the next seq id for the given sequence name
    • getNextSeqIdLong

      Long getNextSeqIdLong(String seqName)
      Get the next guaranteed unique seq id from the sequence with the given sequence name; if the named sequence doesn't exist, it will be created
      Parameters:
      seqName - The name of the sequence to get the next seq id from
      Returns:
      Long with the next sequenced id for the given sequence name
    • getNextSeqIdLong

      Long getNextSeqIdLong(String seqName, long staggerMax)
      Get the next guaranteed unique seq id from the sequence with the given sequence name; if the named sequence doesn't exist, it will be created
      Parameters:
      seqName - The name of the sequence to get the next seq id from
      staggerMax - The maximum amount to stagger the sequenced ID, if 1 the sequence will be incremented by 1, otherwise the current sequence ID will be incremented by a value between 1 and staggerMax
      Returns:
      Long with the next seq id for the given sequence name
    • getOriginalDelegatorName

      String getOriginalDelegatorName()
      Gets the name of the server configuration that corresponds to this delegator
      Returns:
      server configuration name
    • getRelated

      List<GenericValue> getRelated(String relationName, Map<String,? extends Object> byAndFields, List<String> orderBy, GenericValue value, boolean useCache) throws GenericEntityException
      Get the named Related Entity for the GenericValue from the persistent store
      Parameters:
      relationName - String containing the relation name which is the combination of relation.title and relation.rel-entity-name as specified in the entity XML definition file
      byAndFields - the fields that must equal in order to keep; may be null
      orderBy - The fields of the named entity to order the query by; may be null; optionally add a " ASC" for ascending or " DESC" for descending
      value - GenericValue instance containing the entity
      useCache - Whether to cache the results
      Returns:
      List of GenericValue instances as specified in the relation definition
      Throws:
      GenericEntityException
    • getRelatedDummyPK

      GenericPK getRelatedDummyPK(String relationName, Map<String,? extends Object> byAndFields, GenericValue value) throws GenericEntityException
      Get a dummy primary key for the named Related Entity for the GenericValue.
      Parameters:
      relationName - String containing the relation name which is the combination of relation.title and relation.rel-entity-name as specified in the entity XML definition file
      byAndFields - the fields that must equal in order to keep; may be null
      value - GenericValue instance containing the entity
      Returns:
      GenericPK containing a possibly incomplete PrimaryKey object representing the related entity or entities
      Throws:
      GenericEntityException
    • getRelatedOne

      GenericValue getRelatedOne(String relationName, GenericValue value, boolean useCache) throws GenericEntityException
      Get related entity where relation is of type one, uses findByPrimaryKey
      Parameters:
      relationName - String containing the relation name which is the combination of relation.title and relation.rel-entity-name as specified in the entity XML definition file
      value - GenericValue instance containing the entity
      useCache - Whether to cache the results
      Returns:
      GenericValue that is the related entity
      Throws:
      IllegalArgumentException - if the list found has more than one item
      GenericEntityException
    • initEntityEcaHandler

      void initEntityEcaHandler()
    • initDistributedCacheClear

      void initDistributedCacheClear()
    • makePK

      GenericPK makePK(Element element)
    • makePK

      GenericPK makePK(String entityName)
      Creates a Primary Key in the form of a GenericPK without persisting it
    • makePK

      GenericPK makePK(String entityName, Map<String,? extends Object> fields)
      Creates a Primary Key in the form of a GenericPK without persisting it
    • makePK

      GenericPK makePK(String entityName, Object... fields)
      Creates a Primary Key in the form of a GenericPK without persisting it
    • makePKSingle

      GenericPK makePKSingle(String entityName, Object singlePkValue)
      Creates a Primary Key in the form of a GenericPK without persisting it
    • makeTestDelegator

      Delegator makeTestDelegator(String delegatorName)
    • makeValidValue

      GenericValue makeValidValue(String entityName, Map<String,? extends Object> fields)
      Creates a Entity in the form of a GenericValue without persisting it; only valid fields will be pulled from the fields Map
    • makeValidValue

      GenericValue makeValidValue(String entityName, Object... fields)
      Creates a Entity in the form of a GenericValue without persisting it; only valid fields will be pulled from the fields Map
    • makeValue

      GenericValue makeValue(Element element)
    • makeValue

      GenericValue makeValue(String entityName)
      Creates a Entity in the form of a GenericValue without persisting it
    • makeValue

      GenericValue makeValue(String entityName, Map<String,? extends Object> fields)
      Creates a Entity in the form of a GenericValue without persisting it
    • makeValue

      GenericValue makeValue(String entityName, Object... fields)
      Creates a Entity in the form of a GenericValue without persisting it
    • makeValues

      List<GenericValue> makeValues(Document document)
    • makeValueSingle

      GenericValue makeValueSingle(String entityName, Object singlePkValue)
      Creates a Entity in the form of a GenericValue without persisting it
    • putAllInPrimaryKeyCache

      void putAllInPrimaryKeyCache(List<GenericValue> values)
    • putInPrimaryKeyCache

      void putInPrimaryKeyCache(GenericPK primaryKey, GenericValue value)
    • readXmlDocument

      Throws:
      SAXException
      ParserConfigurationException
      IOException
    • refresh

      void refresh(GenericValue value) throws GenericEntityException
      Refresh the Entity for the GenericValue from the persistent store
      Parameters:
      value - GenericValue instance containing the entity to refresh
      Throws:
      GenericEntityException
    • refreshFromCache

      void refreshFromCache(GenericValue value) throws GenericEntityException
      Refresh the Entity for the GenericValue from the cache
      Parameters:
      value - GenericValue instance containing the entity to refresh
      Throws:
      GenericEntityException
    • refreshSequencer

      void refreshSequencer()
      Refreshes the ID sequencer clearing all cached bank values.
    • removeAll

      int removeAll(List<? extends GenericEntity> dummyPKs) throws GenericEntityException

      Remove the Entities from the List from the persistent store.

      The List contains GenericEntity objects, can be either GenericPK or GenericValue.

      If a certain entity contains a complete primary key, the entity in the datasource corresponding to that primary key will be removed, this is like a removeByPrimary Key.

      On the other hand, if a certain entity is an incomplete or non primary key, if will behave like the removeByAnd method.

      These updates all happen in one transaction, so they will either all succeed or all fail, if the data source supports transactions.

      Parameters:
      dummyPKs - Collection of GenericEntity instances containing the entities or by and fields to remove
      Returns:
      int representing number of rows effected by this operation
      Throws:
      GenericEntityException
    • removeAll

      int removeAll(String entityName) throws GenericEntityException
      Throws:
      GenericEntityException
    • removeByAnd

      int removeByAnd(String entityName, Map<String,? extends Object> fields) throws GenericEntityException
      Removes/deletes Generic Entity records found by all of the specified fields (ie: combined using AND)
      Parameters:
      entityName - The Name of the Entity as defined in the entity XML file
      fields - The fields of the named entity to query by with their corresponding values
      Returns:
      int representing number of rows effected by this operation
      Throws:
      GenericEntityException
    • removeByAnd

      int removeByAnd(String entityName, Object... fields) throws GenericEntityException
      Removes/deletes Generic Entity records found by all of the specified fields (ie: combined using AND)
      Parameters:
      entityName - The Name of the Entity as defined in the entity XML file
      fields - The fields of the named entity to query by with their corresponding values
      Returns:
      int representing number of rows effected by this operation
      Throws:
      GenericEntityException
    • removeByCondition

      int removeByCondition(String entityName, EntityCondition condition) throws GenericEntityException
      Removes/deletes Generic Entity records found by the condition
      Parameters:
      entityName - The Name of the Entity as defined in the entity XML file
      condition - The condition used to restrict the removing
      Returns:
      int representing number of rows effected by this operation
      Throws:
      GenericEntityException
    • removeByPrimaryKey

      int removeByPrimaryKey(GenericPK primaryKey) throws GenericEntityException
      Remove a Generic Entity corresponding to the primaryKey
      Parameters:
      primaryKey - The primary key of the entity to remove.
      Returns:
      int representing number of rows effected by this operation
      Throws:
      GenericEntityException
    • removeRelated

      int removeRelated(String relationName, GenericValue value) throws GenericEntityException
      Remove the named Related Entity for the GenericValue from the persistent store
      Parameters:
      relationName - String containing the relation name which is the combination of relation.title and relation.rel-entity-name as specified in the entity XML definition file
      value - GenericValue instance containing the entity
      Returns:
      int representing number of rows effected by this operation
      Throws:
      GenericEntityException
    • removeValue

      int removeValue(GenericValue value) throws GenericEntityException
      Remove a Generic Value from the database
      Parameters:
      value - The GenericValue object of the entity to remove.
      Returns:
      int representing number of rows effected by this operation
      Throws:
      GenericEntityException
    • rollback

      void rollback()
    • setDistributedCacheClear

      void setDistributedCacheClear(DistributedCacheClear distributedCacheClear)
    • setEntityCrypto

      void setEntityCrypto(EntityCrypto crypto)
    • setEntityEcaHandler

      <T> void setEntityEcaHandler(EntityEcaHandler<T> entityEcaHandler)
    • setNextSubSeqId

      void setNextSubSeqId(GenericValue value, String seqFieldName, int numericPadding, int incrementBy)
      Look at existing values for a sub-entity with a sequenced secondary ID, and get the highest plus 1
    • setSequencer

      void setSequencer(SequenceUtil sequencer)
      Allows you to pass a SequenceUtil class (possibly one that overrides the getNextSeqId method); if null is passed will effectively refresh the sequencer.
    • store

      int store(GenericValue value) throws GenericEntityException
      Store the Entity from the GenericValue to the persistent store
      Parameters:
      value - GenericValue instance containing the entity
      Returns:
      int representing number of rows effected by this operation
      Throws:
      GenericEntityException
    • storeAll

      int storeAll(List<GenericValue> values) throws GenericEntityException

      Store the Entities from the List GenericValue instances to the persistent store.

      This is different than the normal store method in that the store method only does an update, while the storeAll method checks to see if each entity exists, then either does an insert or an update as appropriate.

      These updates all happen in one transaction, so they will either all succeed or all fail, if the data source supports transactions. This is just like to othersToStore feature of the GenericEntity on a create or store.

      Parameters:
      values - List of GenericValue instances containing the entities to store
      Returns:
      int representing number of rows effected by this operation
      Throws:
      GenericEntityException
    • storeAll

      int storeAll(List<GenericValue> values, EntityStoreOptions storeOptions) throws GenericEntityException

      Store the Entities from the List GenericValue instances to the persistent store.

      This is different than the normal store method in that the store method only does an update, while the storeAll method checks to see if each entity exists, then either does an insert or an update as appropriate.

      These updates all happen in one transaction, so they will either all succeed or all fail, if the data source supports transactions. This is just like to othersToStore feature of the GenericEntity on a create or store.

      Parameters:
      storeOptions - An instance of EntityStoreOptions that specifies advanced store options or null for default values. See the EntityStoreOptions JavaDoc for more details.
      values - List of GenericValue instances containing the entities to store
      Returns:
      int representing number of rows effected by this operation
      Throws:
      GenericEntityException
    • storeByCondition

      int storeByCondition(String entityName, Map<String,? extends Object> fieldsToSet, EntityCondition condition) throws GenericEntityException
      Store a group of values.
      Parameters:
      entityName - The name of the Entity as defined in the entity XML file
      fieldsToSet - The fields of the named entity to set in the database
      condition - The condition that restricts the list of stored values
      Returns:
      int representing number of rows effected by this operation
      Throws:
      GenericEntityException
    • useDistributedCacheClear

      boolean useDistributedCacheClear()
      Get use of Distributed Cache Clear mechanism status
      Returns:
      boolean true if this delegator uses a Distributed Cache Clear mechanism