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.as()
        .denormalized()
        .from(Country.CAPITAL_FK)
        .using(City.POPULATION)
        .caption("Capital pop.")
        .numberGrouping(true),

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

final class NoOfSpeakers implements DerivedValue<Integer> {

  @Serial
  private static final long serialVersionUID = 1;

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

    return null;
  }
}

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

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

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

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

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

Item.DISABLED.as()
        .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 toColumn(Boolean value, Statement statement) throws SQLException {
    return value ? 1 : 0;
  }

  @Override
  public Boolean fromColumn(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.as()
        .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.as()
        .column(REQUIRED_SEARCHABLE)
        .maximumLength(160),

Album.INSERT_TIME.as()
        .column(INSERT_TIME),
Album.INSERT_USER.as()
        .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.as()
            .attributes(
                    Customer.ID.as()
                            .primaryKey()
                            .generator(identity()),
                    Customer.FIRST_NAME.as()
                            .column(REQUIRED_NAME)
                            .caption("First Name"),
                    Customer.LAST_NAME.as()
                            .column(NAME)
                            .caption("Last Name"),
                    Customer.BIRTH_YEAR.as()
                            .column(positiveNumber(2100))
                            .caption("Age"),
                    Customer.DISCOUNT.as()
                            .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.as(....
      add(Track.TYPE.as()
              .attributes(
                      Track.ID.as()
                              .primaryKey(),
                      Track.NAME.as()
                              .column()
                              .caption("Name")
                              // set the expression since the column 'NAME' is ambiguous
                              .expression("track.name"),
                      Track.ALBUM_ID.as()
                              .column(),
                      Track.ALBUM_FK.as()
                              .foreignKey(),
                      // These columns come from the joined tables,
                      Track.ARTIST_NAME.as()
                              .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.as()
                              .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.as()
              .attributes(
                      AvailableTrack.ID.as()
                              .primaryKey(),
                      AvailableTrack.TITLE.as()
                              .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");

      ReportType<Map<String, Object>, JasperPrint> REPORT = reportType("product_report");
    }

    public Products() {
      super(DOMAIN);
      add(product());
      add(Product.REPORT, classPathReport(Products.class, "product_report.jasper"));
    }

    EntityDefinition product() {
      return Product.TYPE.as()
              .attributes(
                      Product.ID.as()
                              .primaryKey(),
                      Product.NAME.as()
                              .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.as()
              .attributes(
                      Customer.ID.as()
                              .primaryKey(),
                      Customer.NAME.as()
                              .column())
              .build();
    }

    EntityDefinition order() {
      return Order.TYPE.as()
              .attributes(
                      Order.ID.as()
                              .primaryKey(),
                      Order.CUSTOMER_ID.as()
                              .column(),
                      Order.CUSTOMER_FK.as()
                              .foreignKey(),
                      Order.PRODUCT_ID.as()
                              .column(),
                      Order.PRODUCT_FK.as()
                              .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.as()
              .attributes(
                      Employee.ID.as()
                              .primaryKey(),
                      Employee.NAME.as()
                              .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 MyDomain extends DomainModel {
    public MyDomain() {
        super(DOMAIN_TYPE);

        // These can be called in any order without issues
        add(new SharedDomain());
        add(new AnotherDomain());  // May also include SharedDomain

        // Even if both domains above include the same entities,
        // only the first occurrence is registered
    }
}

// Surgical addition via add(EntityDefinition), add(ReportType, Report), etc.
// throws IllegalArgumentException if the type already exists
add(SomeEntity.TYPE.as()...build());  // First time: OK
add(SomeEntity.TYPE.as()...build());  // Second time: throws exception

// To check before surgical addition:
if (!entities().contains(SomeEntity.TYPE)) {
    add(domain.entities().definition(SomeEntity.TYPE));
}

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(), artistTag(), album(), employee(), customer(), genre(), preferences(), mediaType(),
          track(), invoice(), invoiceLine(), playlist(), playlistTrack(), artistRevenue());
  add(Customer.REPORT, export(classPathReport(ChinookImpl.class, "customer_report.jasper"), JRExport.SERIALIZED));
  add(Invoice.REPORT, export(classPathReport(ChinookImpl.class, "invoice.jasper"), JRExport.SERIALIZED));
  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 connection,
                                    RaisePriceParameters parameters) {
    List<Entity> tracks = connection.select(where(Track.ID.in(parameters.trackIds()))
                    .attributes(Track.UNITPRICE)
                    .forUpdate()).stream()
            .map(track -> raisePrice(track, parameters.priceIncrease()))
            .toList();

    return connection.updateSelect(tracks);
  }

  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))
                    .attributes(Invoice.TOTAL, Invoice.CALCULATED_TOTAL)
                    .forUpdate());

    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));
  }
}