Hazelcast Auto DB Integration

final Speedment hazelcastApp = new SakilaApplicationBuilder()
    .withPassword("sakila-password")
    .withBundle(HazelcastBundle.class)
    .build();

public final class FilmImpl extends GeneratedFilmImpl implements Film {}

@GeneratedCode("Speedment")
public abstract class GeneratedFilmImpl implements Film {
    
    private int filmId;
    private String title;
    private String description;
    private Date releaseYear;
    private short languageId;
    private Short originalLanguageId;
    private short rentalDuration;
    private BigDecimal rentalRate;
    private Integer length;
    private BigDecimal replacementCost;
    private String rating;
    private String specialFeatures;
    private Timestamp lastUpdate;
    
    protected GeneratedFilmImpl() {}
    
    @Override 
    public int getFilmId() { return filmId; }
    
    @Override 
    public String getTitle() { return title; }
    
    @Override 
    public Optional<String> getDescription() { return Optional.ofNullable(description); }
    
    // Rest of getters hidden for brevity
    
    @Override
    public Film setFilmId(int filmId) {
        this.filmId = filmId;
        return this;
    }
    
    @Override
    public Film setTitle(String title) {
        this.title = title;
        return this;
    }
    
    @Override
    public Film setDescription(String description) {
        this.description = description;
        return this;
    }    
    // Rest of setters and finders hidden for brevity
    
    @Override 
    public int getFactoryId() { return 1321754994;}
    
    @Override 
    public int getClassId() { return 3143044; }
    
    @Override
    public void writePortable(PortableWriter writer) throws IOException {
        writer.writeInt("film_id", getFilmId());
        writer.writeUTF("title", getTitle());
        writer.writeUTF("description", getDescription().orElse(null));
        if (getReleaseYear().isPresent()){
            writer.writeBoolean("__null__release_year", false);
            writer.writeLong("release_year", getReleaseYear().get().getTime());
        } else {
            writer.writeBoolean("__null__release_year", true);
            writer.writeLong("release_year", Long.MIN_VALUE);
        }
        writer.writeShort("language_id", getLanguageId());
        if (getOriginalLanguageId().isPresent()){
            writer.writeBoolean("__null__original_language_id", false);
            writer.writeShort("original_language_id", getOriginalLanguageId().get());
        } else {
            writer.writeBoolean("__null__original_language_id", true);
            writer.writeShort("original_language_id", Short.MIN_VALUE);
        }
        writer.writeShort("rental_duration", getRentalDuration());
        writer.writeUTF("rental_rate", getRentalRate().toString());
        if (getLength().isPresent()){
            writer.writeBoolean("__null__length", false);
            writer.writeInt("length", getLength().getAsInt());
        } else {
            writer.writeBoolean("__null__length", true);
            writer.writeInt("length", Integer.MIN_VALUE);
        }
        writer.writeUTF("replacement_cost", getReplacementCost().toString());
        writer.writeUTF("rating", getRating().orElse(null));
        writer.writeUTF("special_features", getSpecialFeatures().orElse(null));
        writer.writeLong("last_update", getLastUpdate().getTime());
    }
    
    @Override
    public void readPortable(PortableReader reader) throws IOException {
        setFilmId(reader.readInt("film_id"));
        setTitle(reader.readUTF("title"));
        setDescription(reader.readUTF("description"));
        setReleaseYear(reader.readBoolean("__null__release_year")
            ? null
            : new Date(reader.readLong("release_year")));
        setLanguageId(reader.readShort("language_id"));
        setOriginalLanguageId(reader.readBoolean("__null__original_language_id")
            ? null
            : reader.readShort("original_language_id"));
        setRentalDuration(reader.readShort("rental_duration"));
        setRentalRate(new BigDecimal(reader.readUTF("rental_rate")));
        setLength(reader.readBoolean("__null__length")
            ? null
            : reader.readInt("length"));
        setReplacementCost(new BigDecimal(reader.readUTF("replacement_cost")));
        setRating(reader.readUTF("rating"));
        setSpecialFeatures(reader.readUTF("special_features"));
        setLastUpdate(new Timestamp(reader.readLong("last_update")));
    }
    
    // toString, equals and hashCode hidden for brevity
}

public final class SakilaPortableFactories {
    
    private SakilaPortableFactories() {}
    
    /**
     * A {@link PortableFactory } class for the schema sakila
     * <p>
     * This PortableFactory has an id of 1321754994
     */
    public final static class SakilaSakilaPortableFactory 
    extends GeneratedSakilaSakilaPortableFactory 
    implements PortableFactory {}
}

@GeneratedCode("Speedment")
public final class GeneratedSakilaPortableFactories {
    
    private GeneratedSakilaPortableFactories() {}
    
    /**
     * A {@link PortableFactory } class for the schema sakila
     * <p>
     * This PortableFactory has an id of 1321754994
     */
    public abstract static class GeneratedSakilaSakilaPortableFactory implements PortableFactory {
        
        @Override
        public Portable create(int classId) {
            switch (classId) {
                case 92645877: return new ActorImpl();
                case 1147692044: return new AddressImpl();
                case 50511102: return new CategoryImpl();
                case 3053931: return new CityImpl();
                case 957831062: return new CountryImpl();
                case 606175198: return new CustomerImpl();
                case 3143044: return new FilmImpl();
                case 637325178: return new FilmActorImpl();
                case 205122905: return new FilmCategoryImpl();
                case 1087251704: return new FilmTextImpl();
                case 2020599460: return new InventoryImpl();
                case 1613589672: return new LanguageImpl();
                case 786681338: return new PaymentImpl();
                case 934576860: return new RentalImpl();
                case 109757152: return new StaffImpl();
                case 109770977: return new StoreImpl();
                case 1340382024: return new ActorInfoImpl();
                case 2143869857: return new CustomerListImpl();
                case 1087486343: return new FilmListImpl();
                case 970270416: return new NicerButSlowerFilmListImpl();
                case 47400380: return new SalesByFilmCategoryImpl();
                case 58908876: return new SalesByStoreImpl();
                case 260666013: return new StaffListImpl();
            }
            return null;
        }
    }
}

public class FilmClassDefinition extends GeneratedFilmClassDefinition {}

@GeneratedCode("Speedment")
public abstract class GeneratedFilmClassDefinition implements IntFunction<ClassDefinition> {
    
    protected GeneratedFilmClassDefinition() {}
    
    @Override
    public ClassDefinition apply(int version) {
        return new ClassDefinitionBuilder(1321754994, 3143044, version)
            .addIntField("film_id")
            .addUTFField("title")
            .addUTFField("description")
            .addLongField("release_year")
            .addBooleanField("__null__release_year")
            .addShortField("language_id")
            .addShortField("original_language_id")
            .addBooleanField("__null__original_language_id")
            .addShortField("rental_duration")
            .addUTFField("rental_rate")
            .addIntField("length")
            .addBooleanField("__null__length")
            .addUTFField("replacement_cost")
            .addUTFField("rating")
            .addUTFField("special_features")
            .addLongField("last_update")
            .build();
    }
}

public class SakilaHazelcastConfigComponent extends GeneratedSakilaHazelcastConfigComponent {}

@GeneratedCode("Speedment")
public class GeneratedSakilaHazelcastConfigComponent implements HazelcastConfigComponent {
    
    protected GeneratedSakilaHazelcastConfigComponent() {}
    
    @Override
    public ClientConfig get() {
        final ClientConfig clientConfig = new ClientConfig();
        addPortableFactories(clientConfig);
        addClassDefinitions(clientConfig);
        return clientConfig;
    }
    
    protected void addPortableFactories(ClientConfig clientConfig) {
        clientConfig.getSerializationConfig()
            .addPortableFactory(1321754994, new SakilaSakilaPortableFactory())
        ;
    }
    
    protected void addClassDefinitions(ClientConfig clientConfig) {
        clientConfig.getSerializationConfig()
            .addClassDefinition(new ActorClassDefinition().apply(0))
            .addClassDefinition(new AddressClassDefinition().apply(0))
            .addClassDefinition(new CategoryClassDefinition().apply(0))
            .addClassDefinition(new CityClassDefinition().apply(0))
            .addClassDefinition(new CountryClassDefinition().apply(0))
            .addClassDefinition(new CustomerClassDefinition().apply(0))
            .addClassDefinition(new FilmClassDefinition().apply(0))
            .addClassDefinition(new FilmActorClassDefinition().apply(0))
            .addClassDefinition(new FilmCategoryClassDefinition().apply(0))
            .addClassDefinition(new FilmTextClassDefinition().apply(0))
            .addClassDefinition(new InventoryClassDefinition().apply(0))
            .addClassDefinition(new LanguageClassDefinition().apply(0))
            .addClassDefinition(new PaymentClassDefinition().apply(0))
            .addClassDefinition(new RentalClassDefinition().apply(0))
            .addClassDefinition(new StaffClassDefinition().apply(0))
            .addClassDefinition(new StoreClassDefinition().apply(0))
            .addClassDefinition(new ActorInfoClassDefinition().apply(0))
            .addClassDefinition(new CustomerListClassDefinition().apply(0))
            .addClassDefinition(new FilmListClassDefinition().apply(0))
            .addClassDefinition(new NicerButSlowerFilmListClassDefinition().apply(0))
            .addClassDefinition(new SalesByFilmCategoryClassDefinition().apply(0))
            .addClassDefinition(new SalesByStoreClassDefinition().apply(0))
            .addClassDefinition(new StaffListClassDefinition().apply(0))
        ;
    }
}

    public class MyHazelcastConfigModifierComponent implements HazelcastConfigModifierComponent {

        @Override
        public ClientConfig apply(ClientConfig clientConfig) {
            System.out.println("My custom changes were applied");
            clientConfig.getNetworkConfig().addAddress("192.168.0.234:8234");
            return clientConfig;
        }
    }

   final Speedment hazelcastApp = new SakilaApplicationBuilder()
            .withPassword("sakila-password")
            .withBundle(HazelcastBundle.class)
            .withComponent(MyHazelcastConfigModifierComponent.class)
            .build();

public final class SakilaIngest {
    
    public static void main(final String... argv) {
        if (argv.length == 0) { 
            System.out.println("Usage: " + SakilaIngest.class.getSimpleName() + " database_password");
         } else {
            try (Speedment app = new SakilaApplicationBuilder()
                .withPassword(argv[0]) // Get the password from the first command line parameter
                .withBundle(HazelcastBundle.class)
                .build()) {
            
                IngestUtil.ingest(app).join();
            }
        }
    }
}

    public void ingestAll() {

        // Create a Speedment application connected to a SQL database
        // and that also contains a Hazelcast client
        final Speedment app = new SakilaApplicationBuilder()
            .withPassword("sakila-password")
            .withBundle(HazelcastBundle.class)
            .build();

        // Ingest all tables from the database into the Hazelcast
        // server grid using the default IngestConfiguration:
        // - Load all data (i.e. all rows) from the tables
        // - Use the default ForkJoin pool for parallel loading
        // - Perform loading outside any database transaction
        // - Do not clear the maps before loading
        CompletableFuture<Void> job = IngestUtil.ingest(app);

        // Wait for the ingest job to complete
        job.join();

        // Print out att the distributed maps that now has been
        // created and populated with data
        app.getOrThrow(HazelcastInstanceComponent.class).get()
            .getDistributedObjects()
            .stream()
            .sorted(comparing(Object::toString))
            .forEach(System.out::println);

        // Close the app and thereby also the hazelcastInstance
        app.stop();

    }

    public void ingestAllShort() {

        try (Speedment app = new SakilaApplicationBuilder()
            .withPassword("sakila-password")
            .withBundle(HazelcastBundle.class)
            .build()) {

            IngestUtil.ingest(app).join();
        };

    }

String filmMapName = HazelcastMapUtil.mapName(FilmManager.IDENTIFIER); 

FilmManager films = hazelcastApp.getOrThrow(FilmManager.class);

List<String> list = films.stream()
    .filter(Film.RATING.equal("PG-13"))
    .filter(Film.LENGTH.greaterOrEqua(180))
    .map(Film.TITLE)
    .sorted()
    .collect(Collectors.toList());

        Speedment hazelcastApp = new SakilaApplicationBuilder()
            .withPassword("sakila-password")
            .withBundle(HazelcastBundle.class)
            .withParam("hazelcast.writethrough", "false")
            .build();

public class FilmMapStore extends GeneratedFilmMapStore {
    
    public FilmMapStore(Manager<Film> manager) {
        super(manager);
    }
}

@GeneratedCode("Speedment")
public abstract class GeneratedFilmMapStore extends AbstractMapStore<Integer, Film> {
    
    protected GeneratedFilmMapStore(Manager<Film> manager) {
        super(manager, Film.FILM_ID, new FilmImpl()::setFilmId);
    }
}

    public static final String MAP_NAME = HazelcastMapUtil.mapName(FilmManager.IDENTIFIER);

    public static void main(String... args) {

        final Speedment speedment = new SakilaApplicationBuilder()
            .withPassword("sakila-password")
            .withBundle(HazelcastServerBundle.class) // Use this Bundle server-side
            .build();

        // Creates a config with pre-configured serialization factories an more
        final Config config = new SakilaHazelcastServerConfigComponent().get();

        MapStoreConfig mapStoreConfig = new MapStoreConfig();
        mapStoreConfig.setImplementation(new FilmMapStore(speedment.getOrThrow(FilmManager.class)));
        mapStoreConfig.setWriteDelaySeconds(0);
        mapStoreConfig.setInitialLoadMode(MapStoreConfig.InitialLoadMode.EAGER);

        MapConfig mapConfig = config.getMapConfig(MAP_NAME);
        mapConfig.setMapStoreConfig(mapStoreConfig);

        final HazelcastInstance instance = Hazelcast.newHazelcastInstance(config);

        IMap<Integer, Film> map = instance.getMap(MAP_NAME);

        System.out.println("map.size() = " + map.size());
        
        instance.shutdown();
        speedment.stop();
        
    }

@GeneratedCode("Speedment")
public final class GeneratedSakilaIndexUtil {
    
    private GeneratedSakilaIndexUtil() {}
    
    public static void setupIndex(final HazelcastInstance h) {
        
        // Indexes for table actor
        // Index PRIMARY (unique) using column actor_id
        h.getMap("sakila.sakila.actor").addIndex("actor_id", true);
        // Index idx_actor_last_name  using column last_name
        h.getMap("sakila.sakila.actor").addIndex("last_name", true);
        
        // ... Rows hidden for brevity
        
        // Indexes for table film
        // Index PRIMARY (unique) using column film_id
        h.getMap("sakila.sakila.film").addIndex("film_id", true);
        // Index idx_film_rating  using column rating
        h.getMap("sakila.sakila.film").addIndex("rating", true);
        // Index idx_fk_language_id  using column language_id
        h.getMap("sakila.sakila.film").addIndex("language_id", true);
        // Index idx_fk_original_language_id  using column original_language_id
        h.getMap("sakila.sakila.film").addIndex("original_language_id", true);
        // Index idx_title  using column title
        h.getMap("sakila.sakila.film").addIndex("title", true);
        
        // ... Rows hidden for brevity
    }
}

public class IMapClientExample {

    public static void main(String... args) {

        // Create the Speedment instance with the HazelcastBundle
        Speedment hazelcastApp = new SakilaApplicationBuilder()
            .withPassword("sakila-password")
            .withBundle(HazelcastBundle.class)
            .build();

        // Retrieve the HazecastInstance from the app
        HazelcastInstance hazelcastClient = hazelcastApp.getOrThrow(HazelcastInstanceComponent.class).get();

        // Calculate the IMap name given a TableIdentifier
        String mapName = mapName(FilmManager.IDENTIFIER);
        IMap<Integer, Film> filmMap = hazelcastClient.getMap(mapName);

        Predicate predicate = new SqlPredicate("rating = 'PG-13' and length >= 180");
        Collection<Film> collection = filmMap.values(predicate);

        // print out all Film entities that matches the predicates
        collection
            .forEach(System.out::println);

        // Close the hazelcastApp which, in turn, stops the hazelcastClient
        hazelcastApp.stop();

    }

}

        try(Speedment app = new SakilaApplicationBuilder()
            .withPassword("sakila-password")
            .withBundle(HazelcastBundle.class)
            .build()) {
            
            app.getOrThrow(HazelcastInstanceComponent.class)
                .get()
                .getMap(mapName(FilmManager.IDENTIFIER))
                .values(new SqlPredicate("rating = 'PG-13' and length >= 180"))
                .forEach(System.out::println);
        }

public class StreamClientExample {

    public static void main(String... args) {

        // Create the Speedment instance with the HazelcastBundle
        Speedment hazelcastApp = new SakilaApplicationBuilder()
            .withPassword("sakila-password")
            .withBundle(HazelcastBundle.class)
            .build();

        // Retrieve the FilmManager from the app
        FilmManager films = hazelcastApp.getOrThrow(FilmManager.class);

        // Print out all Film entities that matches the predicates
        films.stream()
            .filter(Film.RATING.equal("PG-13"))
            .filter(Film.LENGTH.greaterOrEqual(180))
            .forEach(System.out::println);

        // Close the hazelcastApp which, in turn, stops the hazelcastClient
        hazelcastApp.stop();

    }

}

        try (Speedment app = new SakilaApplicationBuilder()
            .withPassword("sakila-password")
            .withBundle(HazelcastBundle.class)
            .build()) {

            app.getOrThrow(FilmManager.class).stream()
                .filter(Film.RATING.equal("PG-13"))
                .filter(Film.LENGTH.greaterOrEqual(180))
                .forEach(System.out::println);

        }

        Speedment hazelcastApp = new SakilaApplicationBuilder()
            .withPassword("sakila-password")
            .withBundle(HazelcastBundle.class)
            .withComponent(HazelcastCloudConfig.class, () -> HazelcastCloudConfig.create(
                            "<name of cluster>",
                            "<cluster password>",
                            "<discovery token>")
            )
            .build();