Module is.codion.framework.domain
Package is.codion.framework.domain.entity.condition

Interface Condition

All Known Subinterfaces:
ColumnCondition<T>, Condition.All, Condition.Combination, CustomCondition
public sealed interface Condition permits Condition.All, Condition.Combination, ColumnCondition<T>, CustomCondition (not exhaustive)
Specifies a query condition for filtering entities from the database.

Conditions are the foundation of entity queries, providing type-safe filtering capabilities. They can be simple column-based conditions, foreign key relationships, or complex combinations using logical operators.

Condition.All indicates no condition, as in, all entities should be returned.

Conditions are typically created using column factory methods and combined using logical operators: 

 // Simple conditions using column factory methods
 List<Entity> artists = connection.select(
     Artist.NAME.like("The %"));

 List<Entity> classicalTracks = connection.select(
     Track.GENRE_FK.equalTo(classicalGenre));

 List<Entity> expensiveTracks = connection.select(
     Track.UNIT_PRICE.greaterThan(new BigDecimal("0.99")));

 // Complex conditions using logical combinations
 List<Entity> filteredAlbums = connection.select(and(
     Album.ARTIST_FK.in(selectedArtists),
     Album.TITLE.likeIgnoreCase("%live%")));

 List<Entity> rockOrMetalTracks = connection.select(or(
     Track.GENRE_FK.equalTo(rockGenre),
     Track.GENRE_FK.equalTo(metalGenre)));

 // Key-based conditions
 Entity.Key artistKey = entities.primaryKey(Artist.TYPE, 1);
 List<Entity> albumsByKey = connection.select(
     Album.ARTIST_FK.equalTo(Condition.key(artistKey)));

 // Multiple key conditions
 List<Entity.Key> trackKeys = entities.primaryKeys(Track.TYPE, 1, 2, 3);
 List<Entity> specificTracks = connection.select(
     Condition.keys(trackKeys));

 // Complex nested conditions
 List<Entity> complexQuery = connection.select(
     Select.where(and(
         Album.ARTIST_FK.in(popularArtists),
         or(
             Album.TITLE.likeIgnoreCase("%greatest%"),
             Album.TITLE.likeIgnoreCase("%best%"))))
         .orderBy(ascending(Album.TITLE))
         .build());

 // All entities (no filtering)
 List<Entity> allArtists = connection.select(all(Artist.TYPE));

 // Custom conditions for advanced queries
 List<Entity> customQuery = connection.select(
     Artist.CUSTOM_CONDITION.get("searchParam", searchValue));
See Also:

  • Method Details

    • entityType

      EntityType entityType()
      Returns:
      the entity type

    • values

      List<?> values()
      Returns:
      a list of the values this condition is based on, in the order they appear in the condition clause. An empty list is returned in case no values are specified.

    • columns

      List<Column<?>> columns()
      Returns:
      a list of the columns this condition is based on, in the same order as their respective values appear in the condition clause. An empty list is returned in case no values are specified.

    • string

      String string(EntityDefinition definition)
      Returns a string representing this condition, e.g. "column = ?" or "col1 is not null and col2 in (?, ?)".
      Parameters:
      definition - the entity definition
      Returns:
      a condition string

    • all

      static Condition all(EntityType entityType)
      Parameters:
      entityType - the entity type
      Returns:
      a Condition specifying all entities of the given type

    • key

      static Condition key(Entity.Key key)
      Creates a Condition based on the given key
      Parameters:
      key - the key
      Returns:
      a condition based on the given key

    • keys

      static Condition keys(Collection<Entity.Key> keys)
      Creates a Condition based on the given keys.
      Parameters:
      keys - the keys
      Returns:
      a condition based on the given keys
      Throws:
      IllegalArgumentException - in case keys is empty or if it contains keys from multiple entity types

    • and

      static Condition.Combination and(Condition... conditions)
      Returns a new Condition.Combination instance, combining the given conditions using the AND conjunction.
      Parameters:
      conditions - the conditions to combine
      Returns:
      a new conditions combination

    • and

      static Condition.Combination and(Collection<Condition> conditions)
      Returns a new Condition.Combination instance, combining the given conditions using the AND conjunction.
      Parameters:
      conditions - the conditions to combine
      Returns:
      a new conditions combination

    • or

      static Condition.Combination or(Condition... conditions)
      Returns a new Condition.Combination instance, combining the given conditions using the OR conjunction.
      Parameters:
      conditions - the conditions to combine
      Returns:
      a new conditions combination

    • or

      static Condition.Combination or(Collection<Condition> conditions)
      Returns a new Condition.Combination instance, combining the given conditions using the OR conjunction.
      Parameters:
      conditions - the conditions to combine
      Returns:
      a new conditions combination

    • combination

      static Condition.Combination combination(Conjunction conjunction, Condition... conditions)
      Initializes a new Condition.Combination instance
      Parameters:
      conjunction - the Conjunction to use
      conditions - the conditions to combine
      Returns:
      a new Condition.Combination instance
      Throws:
      IllegalArgumentException - in case conditions is empty

    • combination

      static Condition.Combination combination(Conjunction conjunction, Collection<Condition> conditions)
      Initializes a new Condition.Combination instance
      Parameters:
      conjunction - the Conjunction to use
      conditions - the conditions to combine
      Returns:
      a new Condition.Combination instance
      Throws:
      IllegalArgumentException - in case conditions is empty