Manual

ForeignKey CAPITAL_FK = TYPE.foreignKey("capital_fk", CAPITAL, City.ID);

interface Parent {
  EntityType<Entity> TYPE = DOMAIN.entityType("parent");

  Column<Integer> ID_1 = TYPE.integerColumn("id1");
  Column<Integer> ID_2 = TYPE.integerColumn("id2");
}

interface Child {
  EntityType<Entity> TYPE = DOMAIN.entityType("child");

  Column<Integer> PARENT_ID_1 = TYPE.integerColumn("parent_id1");
  Column<Integer> PARENT_ID_2 = TYPE.integerColumn("parent_id2");

  ForeignKey PARENT_FK = TYPE.foreignKey("parent",
          PARENT_ID_1, Parent.ID_1,
          PARENT_ID_2, Parent.ID_2);
}

public interface World {

  DomainType DOMAIN = DomainType.domainType(World.class);

  interface City {
    EntityType TYPE = DOMAIN.entityType("world.city");

    Column<Integer> ID = TYPE.integerColumn("id");
    Column<String> NAME = TYPE.stringColumn("name");
    Column<String> COUNTRY_CODE = TYPE.stringColumn("countrycode");
    Column<String> DISTRICT = TYPE.stringColumn("district");
    Column<Integer> POPULATION = TYPE.integerColumn("population");

    ForeignKey COUNTRY_FK = TYPE.foreignKey("country_fk", COUNTRY_CODE, Country.CODE);
  }

  interface Country {
    EntityType TYPE = DOMAIN.entityType("world.country");

    Column<String> CODE = TYPE.stringColumn("code");
    Column<String> NAME = TYPE.stringColumn("name");
    Column<String> CONTINENT = TYPE.stringColumn("continent");
    Column<String> REGION = TYPE.stringColumn("region");
    Column<Double> SURFACEAREA = TYPE.doubleColumn("surfacearea");
    Column<Integer> INDEPYEAR = TYPE.integerColumn("indepyear");
    Column<Integer> POPULATION = TYPE.integerColumn("population");
    Column<Double> LIFE_EXPECTANCY = TYPE.doubleColumn("lifeexpectancy");
    Column<Double> GNP = TYPE.doubleColumn("gnp");
    Column<Double> GNPOLD = TYPE.doubleColumn("gnpold");
    Column<String> LOCALNAME = TYPE.stringColumn("localname");
    Column<String> GOVERNMENTFORM = TYPE.stringColumn("governmentform");
    Column<String> HEADOFSTATE = TYPE.stringColumn("headofstate");
    Column<Integer> CAPITAL = TYPE.integerColumn("capital");
    Column<String> CODE_2 = TYPE.stringColumn("code2");
    Column<Integer> CAPITAL_POPULATION = TYPE.integerColumn("capital_population");
    Column<Integer> NO_OF_CITIES = TYPE.integerColumn("no_of_cities");
    Column<Integer> NO_OF_LANGUAGES = TYPE.integerColumn("no_of_languages");
    Column<byte[]> FLAG = TYPE.byteArrayColumn("flag");

    ForeignKey CAPITAL_FK = TYPE.foreignKey("capital_fk", CAPITAL, City.ID);
  }

  interface CountryLanguage {
    EntityType TYPE = DOMAIN.entityType("world.countrylanguage");

    Column<String> COUNTRY_CODE = TYPE.stringColumn("countrycode");
    Column<String> LANGUAGE = TYPE.stringColumn("language");
    Column<Boolean> IS_OFFICIAL = TYPE.booleanColumn("isofficial");
    Column<Double> PERCENTAGE = TYPE.doubleColumn("percentage");
    Column<Integer> NO_OF_SPEAKERS = TYPE.integerColumn("noOfSpeakers");

    ForeignKey COUNTRY_FK = TYPE.foreignKey("country_fk", COUNTRY_CODE, Country.CODE);
  }

  interface Continent {
    EntityType TYPE = DOMAIN.entityType("continent");

    Column<String> NAME = TYPE.stringColumn("continent");
    Column<Integer> SURFACE_AREA = TYPE.integerColumn("sum(surfacearea)");
    Column<Long> POPULATION = TYPE.longColumn("sum(population)");
    Column<Double> MIN_LIFE_EXPECTANCY = TYPE.doubleColumn("min(lifeexpectancy)");
    Column<Double> MAX_LIFE_EXPECTANCY = TYPE.doubleColumn("max(lifeexpectancy)");
    Column<Integer> MIN_INDEPENDENCE_YEAR = TYPE.integerColumn("min(indepyear)");
    Column<Integer> MAX_INDEPENDENCE_YEAR = TYPE.integerColumn("max(indepyear)");
    Column<Double> GNP = TYPE.doubleColumn("sum(gnp)");
  }
}

Country.CAPITAL_POPULATION.define()
        .denormalized()
        .from(Country.CAPITAL_FK)
        .attribute(City.POPULATION)
        .caption("Capital pop.")
        .numberGrouping(true),

CountryLanguage.NO_OF_SPEAKERS.define()
        .derived()
        .from(CountryLanguage.COUNTRY_FK, CountryLanguage.PERCENTAGE)
        .value(new NoOfSpeakers())
        .caption("No. of speakers")
        .numberGrouping(true),

final class NoOfSpeakers implements DerivedValue<Integer> {

  @Serial
  private static final long serialVersionUID = 1;

  @Override
  public Integer get(SourceValues source) {
    Double percentage = source.get(CountryLanguage.PERCENTAGE);
    Entity country = source.get(CountryLanguage.COUNTRY_FK);
    if (percentage != null && country != null && !country.isNull(Country.POPULATION)) {
      return Double.valueOf(country.get(Country.POPULATION) * (percentage / 100)).intValue();
    }

    return null;
  }
}

Country.REGION.define()
        .column()
        .caption("Region")
        .nullable(false)
        .maximumLength(26),
Country.SURFACEAREA.define()
        .column()
        .caption("Surface area")
        .nullable(false)
        .numberGrouping(true)
        .fractionDigits(2),
Country.INDEPYEAR.define()
        .column()
        .caption("Indep. year")
        .range(-2000, 2500),
Country.INDEPYEAR_SEARCHABLE.define()
        .column()
        .expression("to_char(indepyear)")
        .searchable(true)
        .readOnly(true),
Country.POPULATION.define()
        .column()
        .caption("Population")
        .nullable(false)
        .numberGrouping(true),
Country.LIFE_EXPECTANCY.define()
        .column()
        .caption("Life expectancy")
        .fractionDigits(1)
        .range(0, 99),

Country.CODE.define()
        .primaryKey()
        .caption("Code")
        .updatable(true)
        .maximumLength(3),

CountryLanguage.COUNTRY_CODE.define()
        .primaryKey(0)
        .updatable(true),
CountryLanguage.LANGUAGE.define()
        .primaryKey(1)
        .caption("Language")
        .updatable(true),

Country.NO_OF_CITIES.define()
        .subquery("""
                SELECT COUNT(*)
                FROM world.city
                WHERE city.countrycode = country.code""")
        .caption("No. of cities"),

CountryLanguage.IS_OFFICIAL.define()
        .column()
        .caption("Official")
        .withDefault(true)
        .nullable(false),

Item.DISABLED.define()
        .column()
        .converter(Integer.class, new BooleanConverter())
        .caption(Item.DISABLED.name())
        .name("disabled")
        .defaultValue(false)
        .nullable(false)

private static final class BooleanConverter implements Converter<Boolean, Integer> {

  @Override
  public Integer toColumnValue(Boolean value, Statement statement) throws SQLException {
    return value ? 1 : 0;
  }

  @Override
  public Boolean fromColumnValue(Integer columnValue) throws SQLException {
    return columnValue.intValue() == 1;
  }
}

entity.set(Customer.ACTIVE, true);

Boolean isActive = entity.get(Customer.ACTIVE);

private static final List<Item<String>> CONTINENT_ITEMS = List.of(
        item("Africa"), item("Antarctica"), item("Asia"),
        item("Europe"), item("North America"), item("Oceania"),
        item("South America"));

Country.CONTINENT.define()
        .column()
        .items(CONTINENT_ITEMS)
        .caption("Continent")
        .nullable(false),

private static final ColumnTemplate<String> REQUIRED_SEARCHABLE =
        column -> column
                .nullable(false)
                .searchable(true);
private static final ColumnTemplate<LocalDateTime> INSERT_TIME =
        column -> column
                .readOnly(true)
                .captionResource(Chinook.class.getName(), "insert_time");
private static final ColumnTemplate<String> INSERT_USER =
        column -> column
                .readOnly(true)
                .captionResource(Chinook.class.getName(), "insert_user");

Album.TITLE.define()
        .column(REQUIRED_SEARCHABLE)
        .maximumLength(160),

Album.INSERT_TIME.define()
        .column(INSERT_TIME),
Album.INSERT_USER.define()
        .column(INSERT_USER))

public static final class Store extends DomainModel {

  public static final DomainType DOMAIN = DomainType.domainType("store");

  private static final ColumnTemplate<String> NAME =
          column -> column
                  .maximumLength(50)
                  .searchable(true);

  private static final ColumnTemplate<String> REQUIRED =
          column -> column
                  .nullable(false);

  private static final ColumnTemplate<String> REQUIRED_NAME = NAME.and(REQUIRED);

  private static <T extends Number> ColumnTemplate<T> positiveNumber(double maximum) {
    return column -> column
            .nullable(false)
            .minimum(0)
            .maximum(maximum);
  }

  interface Customer {
    EntityType TYPE = DOMAIN.entityType("store.customer");

    Column<Integer> ID = TYPE.integerColumn("id");
    Column<String> FIRST_NAME = TYPE.stringColumn("first_name");
    Column<String> LAST_NAME = TYPE.stringColumn("last_name");
    Column<Integer> BIRTH_YEAR = TYPE.integerColumn("age");
    Column<Double> DISCOUNT = TYPE.doubleColumn("discount");
  }

  public Store() {
    super(DOMAIN);
    add(customer());
  }

  EntityDefinition customer() {
    return Customer.TYPE.define(
                    Customer.ID.define()
                            .primaryKey()
                            .generator(identity()),
                    Customer.FIRST_NAME.define()
                            .column(REQUIRED_NAME)
                            .caption("First Name"),
                    Customer.LAST_NAME.define()
                            .column(NAME)
                            .caption("Last Name"),
                    Customer.BIRTH_YEAR.define()
                            .column(positiveNumber(2100))
                            .caption("Age"),
                    Customer.DISCOUNT.define()
                            .column(positiveNumber(8))
                            .defaultValue(0d)
                            .caption("Discount"))
            .build();
  }
}

.generator(identity()),

//Auto increment column in the 'store.customer' table
.generator(automatic("store.customer"));

//Trigger and a sequence named 'store.customer_seq'
.generator(automatic("store.customer_seq"));

.generator(sequence("world.city_seq")),

.generator(queried("""
        select next_id
        from store.id_values
        where table_name = 'store.customer'"""))

private static final class UUIDGenerator implements Generator<String> {

  @Override
  public void beforeInsert(Entity entity, Column<String> column, Database database, Connection connection) {
    entity.set(column, UUID.randomUUID().toString());
  }
}

  // Domain API
  interface Album {
    EntityType TYPE = DOMAIN.entityType("store.album");

    Column<Long> ID = TYPE.longColumn("id");
    Column<String> TITLE = TYPE.stringColumn("title");
    // Further attributes skipped for brevity
  }

  interface Track {
    EntityType TYPE = DOMAIN.entityType("store.track");

    Column<Long> ID = TYPE.longColumn("id");
    Column<String> NAME = TYPE.stringColumn("name");
    Column<Long> ALBUM_ID = TYPE.longColumn("album_id");
    Column<String> ALBUM_TITLE = TYPE.stringColumn("album_title");
    Column<String> ARTIST_NAME = TYPE.stringColumn("artist_name");

    ForeignKey ALBUM_FK = TYPE.foreignKey("album_fk", ALBUM_ID, Album.ID);
  }

  // Domain implementation
  static class StoreDomain extends DomainModel {
    StoreDomain() {
      super(DOMAIN);
      // add(Album.TYPE.define(....
      add(Track.TYPE.define(
                      Track.ID.define()
                              .primaryKey(),
                      Track.NAME.define()
                              .column()
                              .caption("Name")
                              // set the expression since the column 'NAME' is ambiguous
                              .expression("track.name"),
                      Track.ALBUM_ID.define()
                              .column(),
                      Track.ALBUM_FK.define()
                              .foreignKey(),
                      // These columns come from the joined tables,
                      Track.ARTIST_NAME.define()
                              .column()
                              .caption("Artist")
                              // set the expression since the column 'NAME' is ambiguous
                              .expression("artist.name")
                              .readOnly(true), // always mark denormalized values as read-only
                      Track.ALBUM_TITLE.define()
                              .column()
                              .caption("Album")
                              // No need for an expression, since 'TITLE' is unambiguous
                              .readOnly(true)) // always mark denormalized values as read-only
              // Custom FROM clause to join album and artist tables
              .selectQuery(EntitySelectQuery.builder()
                      .from("store.track " +
                              "JOIN store.album ON track.album_id = album.id " +
                              "JOIN store.artist ON album.artist_id = artist.id")
                      .build())
              .build());
    }
  }

  interface AvailableTrack {
    EntityType TYPE = DOMAIN.entityType("store.available_track");

    Column<Long> ID = TYPE.longColumn("id");
    Column<String> TITLE = TYPE.stringColumn("title");
  }

  static class AvailableTracksDomain extends DomainModel {
    AvailableTracksDomain() {
      super(DOMAIN);
      add(AvailableTrack.TYPE.define(
                      AvailableTrack.ID.define()
                              .primaryKey(),
                      AvailableTrack.TITLE.define()
                              .column()
                              .caption("Title"))
              // Static WHERE clause filters to available tracks only
              .selectQuery(EntitySelectQuery.builder()
                      .from("store.track")
                      .where("available = true")
                      .build())
              .readOnly(true)
              .build());
    }
  }

  // Base domain with product catalog
  static class Products extends DomainModel {

    static final DomainType DOMAIN = domainType("products");

    interface Product {
      EntityType TYPE = DOMAIN.entityType("products.product");

      Column<Integer> ID = TYPE.integerColumn("id");
      Column<String> NAME = TYPE.stringColumn("name");
    }

    public Products() {
      super(DOMAIN);
      add(product());
    }

    EntityDefinition product() {
      return Product.TYPE.define(
                      Product.ID.define()
                              .primaryKey(),
                      Product.NAME.define()
                              .column())
              .build();
    }
  }

  // Orders domain composes Products and adds customer/order entities
  static class Orders extends DomainModel {

    static final DomainType DOMAIN = domainType("orders");

    interface Customer {
      EntityType TYPE = DOMAIN.entityType("orders.customer");

      Column<Integer> ID = TYPE.integerColumn("id");
      Column<String> NAME = TYPE.stringColumn("first_name");
    }

    interface Order {
      EntityType TYPE = DOMAIN.entityType("orders.order");

      Column<Integer> ID = TYPE.integerColumn("id");
      Column<Integer> CUSTOMER_ID = TYPE.integerColumn("customer_id");
      Column<Integer> PRODUCT_ID = TYPE.integerColumn("product_id");

      ForeignKey CUSTOMER_FK = TYPE.foreignKey("customer_fk", CUSTOMER_ID, Customer.ID);
      // Foreign key referencing composed Products domain
      ForeignKey PRODUCT_FK = TYPE.foreignKey("product_fk", PRODUCT_ID, Product.ID);
    }

    public Orders() {
      super(DOMAIN);
      // Include entire Products domain
      add(new Products());
      add(customer(), order());
    }

    EntityDefinition customer() {
      return Customer.TYPE.define(
                      Customer.ID.define()
                              .primaryKey(),
                      Customer.NAME.define()
                              .column())
              .build();
    }

    EntityDefinition order() {
      return Order.TYPE.define(
                      Order.ID.define()
                              .primaryKey(),
                      Order.CUSTOMER_ID.define()
                              .column(),
                      Order.CUSTOMER_FK.define()
                              .foreignKey(),
                      Order.PRODUCT_ID.define()
                              .column(),
                      Order.PRODUCT_FK.define()
                              .foreignKey())
              .build();
    }
  }

  // Store domain composes Orders (which transitively includes Products)
  static class Store extends DomainModel {

    static final DomainType DOMAIN = domainType("store");

    interface Employee {
      EntityType TYPE = DOMAIN.entityType("store.employee");

      Column<Integer> ID = TYPE.integerColumn("id");
      Column<String> NAME = TYPE.stringColumn("first_name");
    }

    public Store() {
      super(DOMAIN);
      // Includes Orders domain (and transitively Products)
      add(new Orders());
      add(employee());
    }

    EntityDefinition employee() {
      return Employee.TYPE.define(
                      Employee.ID.define()
                              .primaryKey(),
                      Employee.NAME.define()
                              .column())
              .build();
    }
  }

  // Website domain selectively includes entities and functionality from other domains
  static class StoreWebSite extends DomainModel {

    static final DomainType DOMAIN = domainType("website");

    public StoreWebSite() {
      super(DOMAIN);
      Entities orderEntities = new Orders().entities();
      // Selectively add specific entities from Orders domain
      add(orderEntities.definition(Product.TYPE));
      add(orderEntities.definition(Customer.TYPE));
      // Include only reports from Products domain
      addReports(new Products());
      // Include only functions from Store domain
      addFunctions(new Store());
      // Include only procedures from Orders domain
      addProcedures(new Orders());
    }
  }

public class StoreTest extends DomainTest {

  private static final Store DOMAIN = new Store();

  public StoreTest() {
    super(DOMAIN, StoreEntityFactory::new);
  }

  @Test
  public void customer() {
    test(Customer.TYPE);
  }

  @Test
  public void address() {
    test(Address.TYPE);
  }

  @Test
  public void customerAddress() {
    test(CustomerAddress.TYPE);
  }

  private static final class StoreEntityFactory extends DefaultEntityFactory {

    private StoreEntityFactory(EntityConnection connection) {
      super(connection);
    }

    @Override
    public Optional<Entity> entity(ForeignKey foreignKey) {
      // See if the currently running test requires an ADDRESS entity
      if (foreignKey.referencedType().equals(Address.TYPE)) {
        return Optional.of(connection().insertSelect(entities().entity(Address.TYPE)
                .with(Address.ID, 21L)
                .with(Address.STREET, "One Way")
                .with(Address.CITY, "Sin City")
                .build()));
      }

      return super.entity(foreignKey);
    }

    @Override
    public Entity entity(EntityType entityType) {
      if (entityType.equals(Address.TYPE)) {
        // Initialize an entity representing a record in the
        // STORE.ADDRESS table, to use for testing
        return entities().entity(Address.TYPE)
                .with(Address.ID, 42L)
                .with(Address.STREET, "Street")
                .with(Address.CITY, "City")
                .with(Address.VALID, true)
                .build();
      }
      else if (entityType.equals(Customer.TYPE)) {
        // Initialize an entity representing a record in the
        // STORE.CUSTOMER table, to use for testing
        return entities().entity(Customer.TYPE)
                .with(Customer.ID, UUID.randomUUID().toString())
                .with(Customer.FIRST_NAME, "Robert")
                .with(Customer.LAST_NAME, "Ford")
                .with(Customer.ACTIVE, true)
                .build();
      }
      else if (entityType.equals(CustomerAddress.TYPE)) {
        return entities().entity(CustomerAddress.TYPE)
                .with(CustomerAddress.CUSTOMER_FK, entity(CustomerAddress.CUSTOMER_FK).orElseThrow())
                .with(CustomerAddress.ADDRESS_FK, entity(CustomerAddress.ADDRESS_FK).orElseThrow())
                .build();
      }

      return super.entity(entityType);
    }

    @Override
    public void modify(Entity entity) {
      if (entity.type().equals(Address.TYPE)) {
        entity.set(Address.STREET, "New Street");
        entity.set(Address.CITY, "New City");
      }
      else if (entity.type().equals(Customer.TYPE)) {
        // It is sufficient to change the value of a
        // single attribute, but the more, the merrier
        entity.set(Customer.FIRST_NAME, "Jesse");
        entity.set(Customer.LAST_NAME, "James");
        entity.set(Customer.ACTIVE, false);
      }
    }
  }
}

FunctionType<EntityConnection, RaisePriceParameters, Collection<Entity>> RAISE_PRICE = functionType("chinook.raise_price");

ProcedureType<EntityConnection, Collection<Long>> UPDATE_TOTALS = procedureType("chinook.update_totals");

FunctionType<EntityConnection, RandomPlaylistParameters, Entity> RANDOM_PLAYLIST = functionType("chinook.random_playlist");

public ChinookImpl() {
  super(DOMAIN);
  add(artist(), album(), employee(), customer(), genre(), preferences(), mediaType(),
          track(), invoice(), invoiceLine(), playlist(), playlistTrack(), artistRevenue());
  add(Customer.REPORT, classPathReport(ChinookImpl.class, "customer_report.jasper"));
  add(Track.RAISE_PRICE, new RaisePrice());
  add(Invoice.UPDATE_TOTALS, new UpdateTotals());
  add(Playlist.RANDOM_PLAYLIST, new CreateRandomPlaylist(entities()));
}

private static final class RaisePrice implements DatabaseFunction<EntityConnection, RaisePriceParameters, Collection<Entity>> {

  @Override
  public Collection<Entity> execute(EntityConnection entityConnection,
                                    RaisePriceParameters parameters) {
    Select select = where(Track.ID.in(parameters.trackIds()))
            .forUpdate()
            .build();

    return entityConnection.updateSelect(entityConnection.select(select).stream()
            .map(track -> raisePrice(track, parameters.priceIncrease()))
            .toList());
  }

  private static Entity raisePrice(Entity track, BigDecimal priceIncrease) {
    track.set(Track.UNITPRICE, track.get(Track.UNITPRICE).add(priceIncrease));

    return track;
  }
}

private static final class UpdateTotals implements DatabaseProcedure<EntityConnection, Collection<Long>> {

  @Override
  public void execute(EntityConnection connection,
                      Collection<Long> invoiceIds) {
    Collection<Entity> invoices =
            connection.select(where(Invoice.ID.in(invoiceIds))
                    .forUpdate()
                    .build());

    connection.update(invoices.stream()
            .map(UpdateTotals::updateTotal)
            .filter(Entity::modified)
            .toList());
  }

  private static Entity updateTotal(Entity invoice) {
    invoice.set(Invoice.TOTAL, invoice.optional(Invoice.CALCULATED_TOTAL).orElse(BigDecimal.ZERO));

    return invoice;
  }
}

private static final class CreateRandomPlaylist implements DatabaseFunction<EntityConnection, RandomPlaylistParameters, Entity> {

  private final Entities entities;

  private CreateRandomPlaylist(Entities entities) {
    this.entities = entities;
  }

  @Override
  public Entity execute(EntityConnection connection,
                        RandomPlaylistParameters parameters) {
    List<Long> trackIds = randomTrackIds(connection, parameters.noOfTracks(), parameters.genres());

    return insertPlaylist(connection, parameters.playlistName(), trackIds);
  }

  private Entity insertPlaylist(EntityConnection connection, String playlistName,
                                List<Long> trackIds) {
    Entity playlist = connection.insertSelect(createPlaylist(playlistName));

    connection.insert(createPlaylistTracks(playlist.primaryKey().value(), trackIds));

    return playlist;
  }

  private Entity createPlaylist(String playlistName) {
    return entities.entity(Playlist.TYPE)
            .with(Playlist.NAME, playlistName)
            .build();
  }

  private List<Entity> createPlaylistTracks(Long playlistId, List<Long> trackIds) {
    return trackIds.stream()
            .map(trackId -> createPlaylistTrack(playlistId, trackId))
            .toList();
  }

  private Entity createPlaylistTrack(Long playlistId, Long trackId) {
    return entities.entity(PlaylistTrack.TYPE)
            .with(PlaylistTrack.PLAYLIST_ID, playlistId)
            .with(PlaylistTrack.TRACK_ID, trackId)
            .build();
  }

  private static List<Long> randomTrackIds(EntityConnection connection, int noOfTracks,
                                           Collection<Entity> genres) {
    return connection.select(Track.ID,
            where(Track.GENRE_FK.in(genres))
                    .orderBy(ascending(Track.RANDOM))
                    .limit(noOfTracks)
                    .build());
  }
}

public void raisePriceOfSelected(BigDecimal increase) {
  if (selection().empty().not().is()) {
    Collection<Long> trackIds = Entity.values(Track.ID, selection().items().get());
    Collection<Entity> result = connection()
            .execute(Track.RAISE_PRICE, new RaisePriceParameters(trackIds, increase));
    replace(result);
  }
}

private static Collection<Entity> updateTotals(Collection<Entity> invoiceLines, EntityConnection connection) {
  // Get the IDs of the invoices that need their totals updated
  Collection<Long> invoiceIds = distinct(InvoiceLine.INVOICE_ID, invoiceLines);
  // Execute the UPDATE_TOTALS procedure
  connection.execute(Invoice.UPDATE_TOTALS, invoiceIds);

  return invoiceLines;
}

public void createRandomPlaylist(RandomPlaylistParameters parameters) {
  EntityConnection connection = connection();
  Entity randomPlaylist = transaction(connection, () -> connection.execute(Playlist.RANDOM_PLAYLIST, parameters));
  items().included().add(0, randomPlaylist);
  selection().item().set(randomPlaylist);
}

public final class ChinookObjectMapperFactory extends DefaultEntityObjectMapperFactory {

  public ChinookObjectMapperFactory() {
    super(Chinook.DOMAIN);
  }

  @Override
  public EntityObjectMapper entityObjectMapper(Entities entities) {
    EntityObjectMapper objectMapper = super.entityObjectMapper(entities);
    objectMapper.parameter(Invoice.UPDATE_TOTALS).set(new TypeReference<>() {});
    objectMapper.parameter(Track.RAISE_PRICE).set(RaisePriceParameters.class);
    objectMapper.parameter(Playlist.RANDOM_PLAYLIST).set(RandomPlaylistParameters.class);
    objectMapper.parameter(Customer.REPORT).set(new TypeReference<>() {});

    return objectMapper;
  }
}

provides is.codion.framework.json.domain.EntityObjectMapperFactory
        with is.codion.demos.chinook.domain.ChinookObjectMapperFactory;

src/main/resources/META-INF/services/is.codion.framework.json.domain.EntityObjectMapperFactory

is.codion.demos.chinook.domain.ChinookObjectMapperFactory

Select selectLiveMetallicaAlbums =
        Select.where(liveMetallicaAlbums)
                .orderBy(OrderBy.descending(Album.NUMBER_OF_TRACKS))
                .build();

List<Entity> albums =
        connection.select(selectLiveMetallicaAlbums);

Update removeLiveMetallicaAlbumCovers =
        Update.where(liveMetallicaAlbums)
                .set(Album.COVER, null)
                .build();

int updateCount =
        connection.update(removeLiveMetallicaAlbumCovers);

Count countAlbumsWithCover =
        Count.where(Album.COVER.isNotNull());

int count = connection.count(countAlbumsWithCover);

EntityConnection connection = connectionProvider.connection();

List<Entity> artists = connection.select(
        Artist.NAME.like("The %"));

List<Entity> nonLiveAlbums = connection.select(and(
        Album.ARTIST_FK.in(artists),
        Album.TITLE.likeIgnoreCase("%live%")));

Entity aliceInChains = connection.selectSingle(
        Artist.NAME.equalTo("Alice In Chains"));

List<Entity> aliceInChainsAlbums = connection.select(
        Album.ARTIST_FK.equalTo(aliceInChains));

Entity metal = connection.selectSingle(
        Genre.NAME.equalToIgnoreCase("metal"));

List<Entity> metalTracks = connection.select(
        Select.where(Track.GENRE_FK.equalTo(metal))
                .attributes(Track.NAME, Track.ALBUM_FK)
                .orderBy(descending(Track.NAME))
                .build());

Long classicalPlaylistId = connection.select(
        Playlist.ID, Playlist.NAME.equalTo("Classical")).get(0);

List<Entity> nonClassicalTracks = connection.select(
        Track.NOT_IN_PLAYLIST.get(Playlist.ID, classicalPlaylistId));

EntityConnection connection = connectionProvider.connection();

Entities entities = connection.entities();

Entity.Key key = entities.primaryKey(Artist.TYPE, 42L);

Entity artist = connection.select(key);

EntityConnection connection = connectionProvider.connection();

Entities entities = connection.entities();

Entity.Key key42 = entities.primaryKey(Artist.TYPE, 42L);
Entity.Key key43 = entities.primaryKey(Artist.TYPE, 43L);

Collection<Entity> artists = connection.select(List.of(key42, key43));

EntityConnection connection = connectionProvider.connection();

List<String> customerUsStates =
        connection.select(Customer.STATE,
                Customer.COUNTRY.equalTo("USA"));

EntityConnection connection = connectionProvider.connection();

try (EntityResultIterator iterator =
             connection.iterator(Customer.EMAIL.isNotNull())) {
  while (iterator.hasNext()) {
    System.out.println(iterator.next().get(Customer.EMAIL));
  }
}

EntityConnection connection = connectionProvider.connection();

List<Entity> employees = connection.select(all(Employee.TYPE));

Map<EntityType, Collection<Entity>> dependencies = connection.dependencies(employees);

Collection<Entity> customersDependingOnEmployees = dependencies.get(Customer.TYPE);

EntityConnection connection = connectionProvider.connection();

int numberOfItStaff = connection.count(
        Count.where(Employee.TITLE.equalTo("IT Staff")));

EntityConnection connection = connectionProvider.connection();

Entities entities = connection.entities();

Entity myBand = entities.entity(Artist.TYPE)
        .with(Artist.NAME, "My Band")
        .build();

myBand = connection.insertSelect(myBand);

Entity firstAlbum = entities.entity(Album.TYPE)
        .with(Album.ARTIST_FK, myBand)
        .with(Album.TITLE, "First album")
        .build();
Entity secondAlbum = entities.entity(Album.TYPE)
        .with(Album.ARTIST_FK, myBand)
        .with(Album.TITLE, "Second album")
        .build();

Collection<Entity.Key> albumKeys =
        connection.insert(List.of(firstAlbum, secondAlbum));

EntityConnection connection = connectionProvider.connection();

Entity myBand = connection.selectSingle(
        Artist.NAME.equalTo("My Band"));

myBand.set(Artist.NAME, "Proper Name");

myBand = connection.updateSelect(myBand);

List<Entity> customersWithoutPhoneNo =
        connection.select(Customer.PHONE.isNull());

customersWithoutPhoneNo.forEach(customer ->
        customer.set(Customer.PHONE, "<none>"));

connection.update(customersWithoutPhoneNo);

EntityConnection connection = connectionProvider.connection();

Entity aquaman = connection.selectSingle(
        Artist.NAME.equalTo("Aquaman"));

List<Long> aquamanAlbumIds = connection.select(Album.ID,
        Album.ARTIST_FK.equalTo(aquaman));

List<Long> aquamanTrackIds = connection.select(Track.ID,
        Track.ALBUM_ID.in(aquamanAlbumIds));

int playlistTracksDeleted = connection.delete(
        PlaylistTrack.TRACK_ID.in(aquamanTrackIds));

int tracksDeleted = connection.delete(
        Track.ALBUM_ID.in(aquamanAlbumIds));

int albumsDeleted = connection.delete(
        Album.ARTIST_FK.equalTo(aquaman));

EntityConnection connection = connectionProvider.connection();

Entity audioslave = connection.selectSingle(
        Artist.NAME.equalTo("Audioslave"));

List<Entity> albums = connection.select(
        Album.ARTIST_FK.equalTo(audioslave));
List<Entity> tracks = connection.select(
        Track.ALBUM_FK.in(albums));
List<Entity> playlistTracks = connection.select(
        PlaylistTrack.TRACK_FK.in(tracks));
List<Entity> invoiceLines = connection.select(
        InvoiceLine.TRACK_FK.in(tracks));

List<Entity> toDelete = new ArrayList<>();
toDelete.addAll(invoiceLines);
toDelete.addAll(playlistTracks);
toDelete.addAll(tracks);
toDelete.addAll(albums);
toDelete.add(audioslave);

connection.delete(Entity.primaryKeys(toDelete));

EntityConnection connection = connectionProvider.connection();

List<Long> trackIds = List.of(123L, 1234L);
BigDecimal priceIncrease = BigDecimal.valueOf(0.1);

Collection<Entity> modifiedTracks =
        connection.execute(Track.RAISE_PRICE,
                new RaisePriceParameters(trackIds, priceIncrease));

String playlistName = "Random playlist";
int numberOfTracks = 100;
Collection<Entity> playlistGenres = connection.select(
        Genre.NAME.in("Classical", "Soundtrack"));

Entity playlist = connection.execute(Playlist.RANDOM_PLAYLIST,
        new RandomPlaylistParameters(playlistName, numberOfTracks, playlistGenres));

EntityConnection connection = connectionProvider.connection();

connection.execute(Invoice.UPDATE_TOTALS, List.of(1234L, 3412L));

EntityConnection connection = connectionProvider.connection();

Map<String, Object> reportParameters = new HashMap<>();
reportParameters.put("CUSTOMER_IDS", List.of(42, 43, 45));

JasperPrint jasperPrint = connection.report(Customer.REPORT, reportParameters);

// This example demonstrates full manual transaction control, including rollback safety
// and protection against leaving transactions open in the presence of unexpected failures.
EntityConnection connection = connectionProvider.connection();

Entities entities = connection.entities();

// It is very important to start the transaction here, outside the try/catch block,
// otherwise, trying to start a transaction on a connection already with an open transaction
// (which is a bug in itself), would cause the current transaction to be rolled back
// in the Exception catch block, which is probably not what you want.
connection.startTransaction();
try {
  Entity artist = entities.entity(Artist.TYPE)
          .with(Artist.NAME, "The Band")
          .build();
  connection.insert(artist);

  Entity album = entities.entity(Album.TYPE)
          .with(Album.ARTIST_FK, artist)
          .with(Album.TITLE, "The Album")
          .build();
  connection.insert(album);

  connection.commitTransaction();
}
catch (DatabaseException e) {
  connection.rollbackTransaction();
  throw e;
}
catch (RuntimeException e) {
  // It is a good practice, but not necessary, to catch RuntimeException,
  // in order to not wrap a RuntimeException in another RuntimeException.
  connection.rollbackTransaction();
  throw e;
}
catch (Exception e) {
  // Always include a catch for the top level Exception, otherwise unexpected
  // exceptions may cause a transaction to remain open, which is a very serious bug.
  connection.rollbackTransaction();
  throw new RuntimeException(e);
}
catch (Throwable e) {
  // It's rare, but including a catch for Throwable ensures rollback safety
  // even in the face of serious errors (e.g., OutOfMemoryError, LinkageError).
  connection.rollbackTransaction();
  throw e;
}

-Dis.codion.framework.db.EntityConnectionProvider.description=MyDescription

java -Dis.codion.framework.db.EntityConnectionProvider.description=production \
     -jar myapp-client.jar

    SwingEntityModel customerModel = new SwingEntityModel(Customer.TYPE, connectionProvider);
    SwingEntityModel invoiceModel = new SwingEntityModel(Invoice.TYPE, connectionProvider);

    // Establish master-detail relationship
    customerModel.detailModels().add(invoiceModel);

    SwingEntityModel customerModel = new SwingEntityModel(Customer.TYPE, connectionProvider);
    EntityEditModel editModel = customerModel.editModel();

    // Access entity values
    Value<String> nameValue = editModel.editor().value(Customer.FIRSTNAME);

    // Perform operations
    editModel.insert();
    editModel.update();
    editModel.delete();

    SwingEntityModel customerModel = new SwingEntityModel(Customer.TYPE, connectionProvider);
    EntityTableModel tableModel = customerModel.tableModel();

    // Refresh data
    tableModel.items().refresh();

    // Access selection
    Collection<Entity> selected = tableModel.selection().items().get();

    SwingEntityModel customerModel = new SwingEntityModel(Customer.TYPE, connectionProvider);
    SwingEntityTableModel tableModel = customerModel.tableModel();
    EntityQueryModel queryModel = tableModel.queryModel();

    // Configure query behavior
    queryModel.limit().set(200);
    queryModel.conditionRequired().set(true);
    queryModel.orderBy().set(OrderBy.ascending(Customer.LASTNAME));

    SwingEntityModel customerModel = new SwingEntityModel(Customer.TYPE, connectionProvider);
    EntityEditModel editModel = customerModel.editModel();
    SwingEntityTableModel tableModel = customerModel.tableModel();

    // Edit model states
    State updateEnabled = editModel.settings().updateEnabled();
    State updateMultipleEnabled = editModel.settings().updateMultipleEnabled();
    ObservableState modified = editModel.editor().modified();

    // Table model states
    ObservableState refreshing = tableModel.items().refresher().active();
    ObservableState hasSelection = tableModel.selection().empty().not();

    // Combine states
    ObservableState canDelete = State.and(hasSelection, refreshing.not());

    SwingEntityModel customerModel = new SwingEntityModel(Customer.TYPE, connectionProvider);
    SwingEntityEditModel editModel = customerModel.editModel();
    SwingEntityTableModel tableModel = customerModel.tableModel();

    // Listen for entity changes
    editModel.afterInsert().addConsumer(entities -> {
      System.out.println("Inserted: " + entities);
    });

    // Listen for selection changes
    tableModel.selection().item().addConsumer(selectedEntity -> {
      if (selectedEntity != null) {
        loadDetails(selectedEntity);
      }
    });

    SwingEntityModel trackModel = new SwingEntityModel(Track.TYPE, connectionProvider);
    EntityEditModel editModel = trackModel.editModel();

    // Bind edit model value to UI state
    EditorValue<BigDecimal> priceValue = editModel.editor().value(Track.UNITPRICE);
    ObservableState priceValid = editModel.editor().value(Track.UNITPRICE).valid();

    // React to value changes
    priceValue.addConsumer(newPrice -> updateTotalPrice(newPrice));

    // React to value edits
    priceValue.edited().addConsumer(newPrice -> System.out.println("Price: " + newPrice));

    // Three-level hierarchy
    SwingEntityModel customerModel = new SwingEntityModel(Customer.TYPE, connectionProvider);
    SwingEntityModel invoiceModel = new SwingEntityModel(Invoice.TYPE, connectionProvider);
    SwingEntityModel invoiceLineModel = new SwingEntityModel(InvoiceLine.TYPE, connectionProvider);

    customerModel.detailModels().add(invoiceModel);
    invoiceModel.detailModels().add(invoiceLineModel);

    // Selection cascades down the hierarchy
    Entity customer = getCustomer(connectionProvider);
    customerModel.tableModel().selection().item().set(customer);
    // Invoices for selected customer are loaded
    Entity invoice = invoiceModel.tableModel().items().included().get(0);
    invoiceModel.tableModel().selection().item().set(invoice);
    // Invoice lines for selected invoice are loaded

    class CustomerTableModel extends SwingEntityTableModel {

      public CustomerTableModel(EntityConnectionProvider connectionProvider) {
        super(new SwingEntityEditModel(Customer.TYPE, connectionProvider));
        // Prevent loading entire customer base
        queryModel().limit().set(100);
        queryModel().conditionRequired().set(true);
      }
    }

    SwingEntityModel invoiceLineModel = new SwingEntityModel(InvoiceLine.TYPE, connectionProvider);

    // Update summary when details change
    invoiceLineModel.editModel().afterInsert().addConsumer(entities -> updateInvoiceTotal());
    invoiceLineModel.editModel().afterUpdate().addConsumer(entities -> updateInvoiceTotal());
    invoiceLineModel.editModel().afterDelete().addConsumer(entities -> updateInvoiceTotal());

    SwingEntityModel customerModel = new SwingEntityModel(Customer.TYPE, connectionProvider);
    SwingEntityTableModel tableModel = customerModel.tableModel();

    // Fetch only Customers with emails by default
    tableModel.queryModel().dataSource().set(queryModel -> {
      EntityConnection connection = queryModel.connectionProvider().connection();

      return connection.select(and(
              Customer.EMAIL.isNotNull(),
              queryModel.condition().where(Conjunction.AND))
      );
    });

    SwingEntityModel customerModel = new SwingEntityModel(Customer.TYPE, connectionProvider);
    EntityTableConditionModel conditionModel = customerModel.tableModel().queryModel().condition();

    // Set condition values
    conditionModel.get(Customer.EMAIL).set().isNotNull();
    conditionModel.get(Customer.COUNTRY).set().equalTo("Iceland");

    // The resulting query will include:
    // WHERE email is not null AND country = 'Iceland'

    SwingEntityModel customerModel = new SwingEntityModel(Customer.TYPE, connectionProvider);
    EntityQueryModel queryModel = customerModel.tableModel().queryModel();

    // Single additional condition
    queryModel.where().conjunction().set(Conjunction.AND);
    queryModel.where().set(() -> Customer.COUNTRY.equalTo("Iceland"));

    // Multiple conditions with custom conjunction
    queryModel.where().set(() -> Condition.or(
            Customer.CITY.equalTo("Reykjavik"),
            Customer.CITY.equalTo("Akureyri")
    ));

    EntitySearchModel searchModel = EntitySearchModel.builder()
            .entityType(Customer.TYPE)
            .connectionProvider(connectionProvider)
            .searchColumns(List.of(Customer.FIRSTNAME, Customer.LASTNAME))
            .build();

    // Get settings for a specific column
    EntitySearchModel.Settings settings = searchModel.settings().get(Customer.LASTNAME);

    // Add wildcards automatically
    settings.wildcardPrefix().set(true);   // Adds % before search text
    settings.wildcardPostfix().set(true);  // Adds % after search text

    // Replace spaces with wildcards
    settings.spaceAsWildcard().set(true);  // "john smith" → "john%smith"

    // Case sensitivity
    settings.caseSensitive().set(false);   // Case-insensitive search

    EntitySearchModel searchModel = EntitySearchModel.builder()
            .entityType(Album.TYPE)
            .connectionProvider(connectionProvider)
            .searchColumns(List.of(Album.TITLE))
            .build();

    // Set selection programmatically
    Entity album = getAlbum(connectionProvider);
    searchModel.selection().entity().set(album);

    // React to selection changes
    searchModel.selection().entity().addConsumer(selectedAlbum -> {
      if (selectedAlbum != null) {
        displayAlbumDetails(selectedAlbum);
      }
    });

    // Clear selection
    searchModel.selection().clear();

    EntitySearchModel searchModel = EntitySearchModel.builder()
            .entityType(Track.TYPE)
            .connectionProvider(connectionProvider)
            .searchColumns(List.of(Track.NAME))
            .build();

    // Get all selected entities
    Collection<Entity> selectedTracks = searchModel.selection().entities().get();

    // Add to selection
    Entity track = getTrack(connectionProvider);
    searchModel.selection().entities().add(track);

    // Remove from selection
    searchModel.selection().entities().remove(track);

    // Replace entire selection
    searchModel.selection().entities().set(List.of(track));

JCheckBox checkBox =
        createCheckBox(Demo.BOOLEAN)
                .build();

NullableCheckBox nullableCheckBox =
        createNullableCheckBox(Demo.BOOLEAN_NULLABLE)
                .build();

JComboBox<Item<Boolean>> comboBox =
        createBooleanComboBox(Demo.BOOLEAN_NULLABLE)
                .build();

EntityComboBox comboBox =
        createComboBox(Demo.FOREIGN_KEY)
                .build();

// Include add/edit buttons
EntityComboBoxPanel comboBoxPanel =
        createComboBoxPanel(Demo.FOREIGN_KEY, this::createEditPanel)
                .includeAddButton(true)
                .includeEditButton(true)
                .build();

EntitySearchField searchField =
        createSearchField(Demo.FOREIGN_KEY)
                .build();

// Include add/edit buttons
EntitySearchFieldPanel searchFieldPanel =
        createSearchFieldPanel(Demo.FOREIGN_KEY, this::createEditPanel)
                .includeAddButton(true)
                .includeEditButton(true)
                .build();

//readOnly
JTextField textField =
        createTextField(Demo.FOREIGN_KEY)
                .build();

TemporalField<LocalDateTime> textField =
        (TemporalField<LocalDateTime>) createTextField(Demo.LOCAL_DATE)
                .build();

TemporalField<LocalDate> localDateField =
        createTemporalField(Demo.LOCAL_DATE)
                .build();

TemporalFieldPanel<LocalDate> temporalPanel =
        createTemporalFieldPanel(Demo.LOCAL_DATE)
                .build();

NumberField<Integer> integerField =
        (NumberField<Integer>) createTextField(Demo.INTEGER)
                .build();

integerField =
        createIntegerField(Demo.INTEGER)
                .build();

NumberField<Long> longField =
        (NumberField<Long>) createTextField(Demo.LONG)
                .build();

longField =
        createLongField(Demo.LONG)
                .build();

NumberField<Double> doubleField =
        (NumberField<Double>) createTextField(Demo.DOUBLE)
                .build();

doubleField =
        createDoubleField(Demo.DOUBLE)
                .build();

NumberField<BigDecimal> bigDecimalField =
        (NumberField<BigDecimal>) createTextField(Demo.BIG_DECIMAL)
                .build();

bigDecimalField =
        createBigDecimalField(Demo.BIG_DECIMAL)
                .build();

JTextField textField =
        createTextField(Demo.TEXT)
                .build();

JFormattedTextField maskedField =
        createMaskedTextField(Demo.FORMATTED_TEXT)
                .mask("###:###")
                .valueContainsLiteralCharacters(true)
                .build();

JTextArea textArea =
        createTextArea(Demo.LONG_TEXT)
                .rowsColumns(5, 20)
                .build();

TextFieldPanel inputPanel =
        createTextFieldPanel(Demo.LONG_TEXT)
                .build();

DefaultComboBoxModel<String> comboBoxModel =
        new DefaultComboBoxModel<>(new String[] {"One", "Two"});

JComboBox<String> comboBox =
        createComboBox(Demo.TEXT, comboBoxModel)
                .editable(true)
                .build();

JComboBox<Item<String>> comboBox =
        createItemComboBox(Demo.ITEM_LIST)
                .build();

    class InvoiceEditPanel extends EntityEditPanel {
      public InvoiceEditPanel(SwingEntityEditModel editModel) {
        super(editModel, config ->
                // Keep displaying newly inserted invoice since we'll continue
                // working with it by adding invoice lines
                config.clearAfterInsert(false));
      }

      @Override
      protected void initializeUI() {
        // UI setup
      }
    }

    class CustomerEditPanel extends EntityEditPanel {
      public CustomerEditPanel(SwingEntityEditModel editModel) {
        super(editModel);
      }

      @Override
      protected void initializeUI() {
        focus().initial().set(Customer.FIRSTNAME);
        focus().afterInsert().set(Customer.ADDRESS);

        // Create your input components...
      }
    }

    class TrackEditPanel extends EntityEditPanel {
      public TrackEditPanel(SwingEntityEditModel editModel) {
        super(editModel);
      }

      @Override
      protected void initializeUI() {
        createComboBoxPanel(Track.MEDIATYPE_FK, this::createMediaTypeEditPanel)
                .preferredWidth(160)
                .includeAddButton(true)
                .includeEditButton(true);

        createSearchFieldPanel(Track.MEDIATYPE_FK, this::createMediaTypeEditPanel)
                .preferredWidth(160)
                .includeAddButton(true)
                .includeEditButton(true);
      }

      private EntityEditPanel createMediaTypeEditPanel() {
        return new MediaTypeEditPanel(new SwingEntityEditModel(MediaType.TYPE, editModel().connectionProvider()));
      }
    }

    class TrackEditPanel extends EntityEditPanel {
      public TrackEditPanel(SwingEntityEditModel editModel) {
        super(editModel);
      }

      @Override
      protected void initializeUI() {
        // Create a custom component and set it as the attribute
        // component, it is automatically linked to the editor value
        component(Track.MILLISECONDS).set(new DurationComponentValue());
      }
    }

    class CustomerEditPanel extends EntityEditPanel {
      public CustomerEditPanel(SwingEntityEditModel editModel) {
        super(editModel);
      }

      @Override
      protected void initializeUI() {
        createTextField(Customer.STATE)
                .keyEvent(KeyEvents.builder()
                        .keyCode(VK_SPACE)
                        .modifiers(MENU_SHORTCUT_MASK)
                        .action(Control.action(this::selectStateFromExistingValues)));
      }

      private void selectStateFromExistingValues(ActionEvent event) {
        JTextField stateField = (JTextField) event.getSource();

        Dialogs.select()
                .list(editModel().connection().select(Customer.STATE))
                .owner(stateField)
                .select()
                .single()
                .ifPresent(stateField::setText);
      }
    }

    class InvoiceEditPanel extends EntityEditPanel {
      private final EntityPanel invoiceLinePanel;

      public InvoiceEditPanel(SwingEntityEditModel editModel, SwingEntityModel invoiceLineModel) {
        super(editModel, config -> config.clearAfterInsert(false));
        this.invoiceLinePanel = createInvoiceLinePanel(invoiceLineModel);
      }

      @Override
      protected void initializeUI() {
        // Initialize main edit controls...

        // Add detail panel
        add(invoiceLinePanel, BorderLayout.SOUTH);
      }

      private EntityPanel createInvoiceLinePanel(SwingEntityModel invoiceLineModel) {
        // Create and return invoice line panel
        return new EntityPanel(invoiceLineModel);
      }
    }

    EntitySearchField searchField = EntitySearchField.builder()
            .model(searchModel)
            .singleSelection()
            .build();

    EntitySearchField searchField = EntitySearchField.builder()
            .model(searchModel)
            .multiSelection()
            .build();

    EntitySearchField searchField = EntitySearchField.builder()
            .model(searchModel)
            .multiSelection()
            .selector(new CustomerSelector())
            .build();

    SwingEntityEditModel editModel = new SwingEntityEditModel(Customer.TYPE, connectionProvider);

    EntitySearchField searchField = EntitySearchField.builder()
            .model(searchModel)
            .singleSelection()
            .editPanel(() -> new CustomerEditPanel(editModel))
            .confirmAdd(true)     // Confirm before adding
            .confirmEdit(true)    // Confirm before editing
            .build();

    // Access controls
    searchField.addControl();   // INSERT key by default
    searchField.editControl();  // CTRL+INSERT by default

    EntitySearchField searchField = EntitySearchField.builder()
            .model(searchModel)
            .multiSelection()
            .searchIndicator(SearchIndicator.PROGRESS_BAR)
            .build();

    EntitySearchField searchField = EntitySearchField.builder()
            .model(searchModel)
            .singleSelection()
            .columns(20)                      // Field width
            .upperCase(true)                  // Force uppercase
            .searchHintEnabled(true)          // Show "Search..." hint
            .searchOnFocusLost(true)          // Auto-search when focus lost
            .selectionToolTip(true)           // Show selection as tooltip
            .editable(false)                  // Make read-only
            .formatter(entity ->        // Custom display text
                    entity.get(Customer.LASTNAME) + " - " + entity.get(Customer.CITY))
            .separator(" | ")                 // Multi-selection separator
            .build();

    SwingEntityEditModel editModel = new SwingEntityEditModel(Invoice.TYPE, connectionProvider);

    ComponentValue<EntitySearchField, Entity> searchFieldValue =
            EntitySearchField.builder()
                    .model(searchModel)
                    .singleSelection()
                    .buildValue();

    EntitySearchField searchField = searchFieldValue.component();
    // React to selection changes
    searchField.model().selection().entities().addConsumer(selectedEntities ->
            System.out.println("Selected: " + selectedEntities));

    // Link to edit model
    editModel.editor().value(Invoice.CUSTOMER_FK).link(searchFieldValue);

class TrackEditComponentFactory extends DefaultEditComponentFactory<Entity, EntitySearchField> {

    @Override
    protected EntitySearchField.SingleSelectionBuilder searchField(
            ForeignKey foreignKey,
            EntityDefinition entityDefinition,
            EntitySearchModel searchModel) {
        return super.searchField(foreignKey, entityDefinition, searchModel)
                .selectorFactory(new TrackSelectorFactory());
    }
}

-Dcodion.db.url=jdbc:postgresql://localhost:5432/mydb
-Dcodion.domain.generator.domainPackage=com.example.domain
-Dcodion.domain.generator.combinedSourceDirectory=generated
-Dcodion.domain.generator.apiSourceDirectory=api
-Dcodion.domain.generator.implSourceDirectory=impl

CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    customer_id INTEGER REFERENCES customers(id)
);

interface Order {
    EntityType TYPE = DOMAIN.entityType("orders");

    Column<Integer> ID = TYPE.integerColumn("id");
    Column<Integer> CUSTOMER_ID = TYPE.integerColumn("customer_id");
    ForeignKey CUSTOMER_FK = TYPE.foreignKey("customer_fk", CUSTOMER_ID, Customer.ID);
}

Order.CUSTOMER_FK.define()
    .foreignKey()
    .caption("Customer")

EntityDefinition customerSummary() {
    return CustomerSummary.TYPE.define(/* ... */)
        .caption("Customer summary")
        .readOnly(true)  // Automatically added for views
        .build();
}

interface Customer {
    EntityType TYPE = DOMAIN.entityType("customer");

    Column<Integer> ID = TYPE.integerColumn("id");
    Column<String> NAME = TYPE.stringColumn("name");
    Column<String> EMAIL = TYPE.stringColumn("email");

    // Generated DTO record
    public static record Dto(
            Integer id,
            String name,
            String email) {

        public Entity entity(Entities entities) {
            return entities.entity(TYPE)
                .with(ID, id)
                .with(NAME, name)
                .with(EMAIL, email)
                .build();
        }
    }

    // Conversion method
    public static Dto dto(Customer customer) {
        return customer == null ? null :
            new Dto(
                customer.get(ID),
                customer.get(NAME),
                customer.get(EMAIL));
    }
}

interface Order {
    Column<Integer> CUSTOMER_ID = TYPE.integerColumn("customer_id");
    ForeignKey CUSTOMER_FK = TYPE.foreignKey("customer_fk",
        CUSTOMER_ID, Customer.ID);

    public static record Dto(
            Integer id,
            Customer.Dto customer) {  // Nested DTO reference (only if Customer has DTO)

        public Entity entity(Entities entities) {
            return entities.entity(TYPE)
                .with(ID, id)
                .with(CUSTOMER_FK, customer.entity(entities))
                .build();
        }
    }
}

// Entity to DTO
Entity customer = connection.selectSingle(Customer.ID.equalTo(42));
Customer.Dto dto = Customer.dto(customer);

// DTO to Entity
Entities entities = connection.entities();
Entity newCustomer = dto.entity(entities);
connection.insert(newCustomer);

customer=Customer
customer.description=Customer master data
id=Id
name=Name
email=Email
email.description=Customer email address

ValueSet<Integer> valueSet =
        ValueSet.<Integer>builder()
                .value(Set.of(1, 2, 3))
                .build();

valueSet.addListener(() -> System.out.println("Values changed"));

valueSet.add(4); //output: Values changed
valueSet.add(1); //no change, no output

valueSet.remove(1); //output: Values changed
System.out.println(valueSet.contains(1)); //output: false

valueSet.clear();

ValueList<Integer> valueList =
        ValueList.<Integer>builder()
                .value(List.of(1, 2, 3))
                .build();

valueList.addListener(() -> System.out.println("Values changed"));

valueList.add(4); //output: Values changed
valueList.add(1); //output: Values changed

valueList.remove(1); //output: Values changed
System.out.println(valueList.contains(1)); //output: true

valueList.clear();

State updateEnabled = State.state();
State insertEnabled = State.state();

State recordNew = State.state();
State recordModified = State.state();

ObservableState saveButtonEnabled = State.and(
        State.or(insertEnabled, updateEnabled),
        State.or(recordNew, recordModified));

JButton saveButton = new JButton("Save");

Utilities.enabled(saveButtonEnabled, saveButton);

State state = State.state();

Action action = new AbstractAction("action") {
  @Override
  public void actionPerformed(ActionEvent e) {
    System.out.println("Hello Action");
  }
};

Utilities.enabled(state, action);

System.out.println(action.isEnabled());// output: false

state.set(true);

System.out.println(action.isEnabled());// output: true

State state = State.state();

CommandControl control = Control.builder()
        .command(() -> System.out.println("Hello Control"))
        .enabled(state)
        .build();

System.out.println(control.isEnabled());// output: false

state.set(true);

System.out.println(control.isEnabled());// output: true

FilterListSelection<Person> selection = tableModel.selection();

// Print the selected items when they change
selection.items().addConsumer(System.out::println);

// Print a message when the minimum selected index changes
selection.index().addListener(() ->
        System.out.println("Selected index changed"));

// Select the first row
selection.index().set(0);

// Select the first two rows
selection.indexes().set(List.of(0, 1));

// Fetch the selected items
List<Person> items = selection.items().get();

// Or just the first (minimum index)
Person item = selection.item().get();

// Select a specific person
selection.item().set(new Person("John", 42));

// Select all persons over 40
selection.items().set(person -> person.age() > 40);

// Increment all selected indexes by
// one, moving the selection down
selection.indexes().increment();

// Clear the selection
selection.clear();

TableConditionModel<String> filters = tableModel.filters();

// Filter out people under 40 years old
ConditionModel<Integer> ageFilter = filters.get(Person.AGE);

ageFilter.set().greaterThanOrEqualTo(40);
// Not necessary since filters auto-enable by default
// when operators and operands are specified
ageFilter.enabled().set(true);

// Filter is automatically disabled when it is cleared
ageFilter.clear();

// Filter out anyone besides John and Joan
ConditionModel<String> nameFilter = filters.get(NAME);

nameFilter.caseSensitive().set(false);
nameFilter.set().equalTo("jo%");

// Clear all filters
filters.clear();

FilterTableSort<Person, String> sort = tableModel.sort();

// Sort by age and name, ascending
sort.ascending(AGE, NAME);

// Sort by age, descending,
// set() clears the previous sort
sort.order(AGE).set(DESCENDING);
// add sorting by name, ascending,
// add() adds to any previous sort
sort.order(NAME).add(ASCENDING);

// Clear the sorting
sort.clear();

String tabDelimited = tableModel.export()
        // Specify columns (default all, so not really necessary here)
        .columns(List.of(Person.NAME, Person.AGE))
        // Tab delimited
        .delimiter('\t')
        // Include header
        .header(true)
        // Only selected rows
        .selected(true)
        .get();

FilterTableColumnModel<String> columns = table.columnModel();

// Reorder the columns
columns.visible().set(Person.AGE, Person.NAME);

// Print hidden columns when they change
columns.hidden().addConsumer(System.out::println);

// Hide the age column
columns.visible(Person.AGE).set(false);

// Only show the age column
columns.visible().set(Person.AGE);

// Reset columns to their default location and visibility
columns.reset();

FilterTableSearchModel search = table.search();

// Search for the value "43" in the table
search.predicate().set(value -> value.equals("43"));

RowColumn searchResult = search.results().current().get();

System.out.println(searchResult); // row: 1, column: 1

// Print the next available result
search.results().next().ifPresent(System.out::println);

Value<String> stringValue = Value.nullable();

JTextField textField =
        Components.stringField()
                .link(stringValue)
                .preferredWidth(120)
                .transferFocusOnEnter(true)
                .build();

Value<Character> characterValue = Value.nullable();

JTextField textField =
        Components.characterField()
                .link(characterValue)
                .preferredWidth(120)
                .transferFocusOnEnter(true)
                .build();

Value<String> stringValue = Value.nullable();

JTextArea textArea =
        Components.textArea()
                .link(stringValue)
                .rowsColumns(10, 20)
                .lineWrap(true)
                .build();

Value<Integer> integerValue = Value.nullable();

NumberField<Integer> integerField =
        Components.integerField()
                .link(integerValue)
                .range(0, 10_000)
                .grouping(false)
                .build();

Value<Long> longValue = Value.nullable();

NumberField<Long> longField =
        Components.longField()
                .link(longValue)
                .grouping(true)
                .build();

Value<Double> doubleValue = Value.nullable();

NumberField<Double> doubleField =
        Components.doubleField()
                .link(doubleValue)
                .fractionDigits(3)
                .decimalSeparator('.')
                .build();

Value<BigDecimal> bigDecimalValue = Value.nullable();

NumberField<BigDecimal> bigDecimalField =
        Components.bigDecimalField()
                .link(bigDecimalValue)
                .fractionDigits(2)
                .groupingSeparator('.')
                .decimalSeparator(',')
                .build();

Value<LocalTime> localTimeValue = Value.nullable();

TemporalField<LocalTime> temporalField =
        Components.localTimeField()
                .link(localTimeValue)
                .dateTimePattern("HH:mm:ss")
                .build();

Value<LocalDate> localDateValue = Value.nullable();

TemporalField<LocalDate> temporalField =
        Components.localDateField()
                .link(localDateValue)
                .dateTimePattern("dd-MM-yyyy")
                .build();

Value<LocalDateTime> localDateTimeValue = Value.nullable();

TemporalField<LocalDateTime> temporalField =
        Components.localDateTimeField()
                .link(localDateTimeValue)
                .dateTimePattern("dd-MM-yyyy HH:mm")
                .build();

//non-nullable so use this value instead of null
boolean nullValue = false;

Value<Boolean> booleanValue =
        Value.builder()
                .nonNull(nullValue)
                .value(true)
                .build();

JCheckBox checkBox =
        Components.checkBox()
                .link(booleanValue)
                .text("Check")
                .horizontalAlignment(SwingConstants.CENTER)
                .build();

//nullable boolean value
Value<Boolean> booleanValue = Value.nullable();

NullableCheckBox checkBox =
        Components.nullableCheckBox()
                .link(booleanValue)
                .text("Check")
                .build();

Value<Boolean> booleanValue = Value.nullable();

JComboBox<Item<Boolean>> comboBox =
        Components.booleanComboBox()
                .link(booleanValue)
                .toolTipText("Select a value")
                .build();

Value<String> stringValue = Value.nullable();

DefaultComboBoxModel<String> comboBoxModel =
        new DefaultComboBoxModel<>(new String[] {"one", "two", "three"});

JComboBox<String> comboBox =
        Components.comboBox()
                .model(comboBoxModel)
                .link(stringValue)
                .preferredWidth(160)
                .build();

class Person {
  final String firstName;
  final String lastName;

  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }

  @Override
  public String toString() {
    return lastName + ", " + firstName;
  }
}

class PersonPanel extends JPanel {
  final JTextField firstNameField = new JTextField();
  final JTextField lastNameField = new JTextField();

  public PersonPanel() {
    setLayout(new GridLayout(2, 2));
    add(new JLabel("First name"));
    add(new JLabel("Last name"));
    add(firstNameField);
    add(lastNameField);
  }
}

class PersonPanelValue extends AbstractComponentValue<PersonPanel, Person> {

  public PersonPanelValue(PersonPanel component) {
    super(component);
    //We must call notifyListeners() each time this value changes,
    //that is, when either the first or last name changes.
    component.firstNameField.getDocument()
            .addDocumentListener((DocumentAdapter) e -> notifyObserver());
    component.lastNameField.getDocument()
            .addDocumentListener((DocumentAdapter) e -> notifyObserver());
  }

  @Override
  protected Person getComponentValue() {
    return new Person(component().firstNameField.getText(), component().lastNameField.getText());
  }

  @Override
  protected void setComponentValue(Person value) {
    component().firstNameField.setText(value == null ? null : value.firstName);
    component().lastNameField.setText(value == null ? null : value.lastName);
  }
}

Value<Person> personValue = Value.nullable();

PersonPanel personPanel = new PersonPanel();

Value<Person> personPanelValue = new PersonPanelValue(personPanel);

personPanelValue.link(personValue);

Dialogs.select()
        .list(List.of("One", "Two", "Three"))
        .owner(window)
        .title("Select a number")
        .select()
        .single()
        .ifPresent(System.out::println);

Collection<String> selected = Dialogs.select()
        .list(List.of("One", "Two", "Three", "Four"))
        .owner(window)
        .title("Select numbers")
        .select()
        .multiple();

File file = Dialogs.select()
        .files()
        .owner(window)
        .title("Select a file")
        .selectFile();

Collection<File> files = Dialogs.select()
        .files()
        .owner(window)
        .title("Select files")
        .filter(new FileNameExtensionFilter("PDF files", "pdf"))
        .selectFiles();

File fileToSave = Dialogs.select()
        .files()
        .owner(window)
        .title("Select file to save")
        .confirmOverwrite(false)
        .selectFileToSave("default-filename.txt");

File directory = Dialogs.select()
        .files()
        .owner(window)
        .title("Select a directory")
        .selectDirectory();

Collection<File> directories = Dialogs.select()
        .files()
        .owner(window)
        .title("Select directories")
        .selectDirectories();

File fileOrDirectory = Dialogs.select()
        .files()
        .owner(window)
        .title("Select file or directory")
        .selectFileOrDirectory();

Collection<File> filesOrDirectories = Dialogs.select()
        .files()
        .owner(window)
        .title("Select files and/or directories")
        .selectFilesOrDirectories();

Dialogs.okCancel()
        .owner(window)
        .title("Title")
        .onOk(this::onOk)
        .onCancel(this::onCancel)
        .show();

Dialogs.action()
        .owner(window)
        .title("Title")
        .defaultAction(Control.builder()
                .command(this::onOk)
                .caption(Messages.ok())
                .build())
        .escapeAction(Control.builder()
                .command(this::onCancel)
                .caption(Messages.cancel())
                .build())
        .show();