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

Interface ColumnCondition<T>

Type Parameters:
T - the attribute type
All Superinterfaces:
Condition
public interface ColumnCondition<T> extends Condition
A condition based on a single Column.

ColumnConditions provide type-safe filtering for column values using various operators such as equality, comparison, pattern matching, and range operations. String conditions support case-sensitive and case-insensitive variants.

Column conditions are typically created through the Column.Factory interface, which all Column instances implement: 

 // Equality conditions
 List<Entity> metalTracks = connection.select(
     Track.GENRE_FK.equalTo(metalGenre));

 List<Entity> unpriced = connection.select(
     Track.UNIT_PRICE.equalTo(null)); // Becomes "IS NULL"

 // String pattern matching
 List<Entity> theArtists = connection.select(
     Artist.NAME.like("The %"));

 List<Entity> liveAlbums = connection.select(
     Album.TITLE.likeIgnoreCase("%live%"));

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

 List<Entity> recentTracks = connection.select(
     Track.CREATED_DATE.greaterThanOrEqualTo(
         LocalDateTime.now().minusDays(30)));

 // Range conditions
 List<Entity> mediumPricedTracks = connection.select(
     Track.UNIT_PRICE.between(
         new BigDecimal("0.50"),
         new BigDecimal("1.50")));

 // Collection-based conditions
 List<String> genres = List.of("Rock", "Metal", "Blues");
 List<Entity> rockishTracks = connection.select(
     Track.GENRE_NAME.inIgnoreCase(genres));

 List<Integer> excludedIds = List.of(1, 5, 10);
 List<Entity> filteredArtists = connection.select(
     Artist.ID.notIn(excludedIds));

 // Null checks
 List<Entity> tracksWithPrice = connection.select(
     Track.UNIT_PRICE.isNotNull());

 List<Entity> tracksWithoutComposer = connection.select(
     Track.COMPOSER.isNull());

 // Case-insensitive operations
 List<Entity> beatlesAlbums = connection.select(
     Album.ARTIST_NAME.equalToIgnoreCase("the beatles"));

 // Complex combinations with logical operators
 List<Entity> complexQuery = connection.select(and(
     Track.UNIT_PRICE.greaterThan(new BigDecimal("0.99")),
     Track.GENRE_NAME.inIgnoreCase("Rock", "Metal"),
     Track.DURATION.lessThan(300000))); // Less than 5 minutes
See Also:

  • Method Details

    • column

      Column<T> column()
      Returns:
      the attribute

    • operator

      Operator operator()
      Returns:
      the condition operator

    • caseSensitive

      boolean caseSensitive()
      Returns:
      true if this condition is case-sensitive, only applies to String based conditions

    • factory

      static <T> ColumnCondition.Factory<T> factory(Column<T> column)
      Instantiates a new ColumnCondition.Factory instance
      Type Parameters:
      T - the column type
      Parameters:
      column - the column
      Returns:
      a new ColumnCondition.Factory instance