Holon Platform tutorial: The Datastore API

public void testSave() {

  // Create a new product
  PropertyBox product = PropertyBox.builder(PRODUCT).set(SKU, "prod1-sku").set(DESCRIPTION, "The first product")
      .set(CATEGORY, "C1").set(UNIT_PRICE, 10.90).build();
  // store the product
  OperationResult result = datastore.save(TARGET, product); (1)

  // check to operation succeded
  assertEquals(1, result.getAffectedCount());

  // get the created product ID (the ID column is configured as auto-increment)
  Long productId = result.getInsertedKey(ID).orElse(null); (2)
  assertEquals(Long.valueOf(1), productId);

  // Create another product
  PropertyBox product2 = product.cloneBox();
  product2.setValue(SKU, "prod2-sku");
  product2.setValue(UNIT_PRICE, 12.90);
  product2.setValue(DESCRIPTION, "The second product");

  // store the product using the BRING_BACK_GENERATED_IDS option
  datastore.save(TARGET, product2, DefaultWriteOption.BRING_BACK_GENERATED_IDS); (3)

  // the generated id now is stored in the PropertyBox by the Datastore
  Long productId2 = product2.getValue(ID); (4)
  assertEquals(Long.valueOf(2), productId2);
}

public void testQuery() {

  // get all products (as a Stream) and print the description
  datastore.query().target(TARGET).stream(PRODUCT).map(p -> p.getValue(DESCRIPTION)).forEach(description -> {
    System.out.println(description);
  });

  // get a product by id
  PropertyBox product = datastore.query().target(TARGET).filter(ID.eq(1L)).findOne(PRODUCT).orElse(null);
  assertNotNull(product);

  // get all product ids, ordered by SKU
  List<Long> ids = datastore.query().target(TARGET).sort(SKU.asc()).stream(ID).collect(Collectors.toList());

  assertEquals(2, ids.size());

  // get only the ID and DESCRITION product property values
  Stream<PropertyBox> productIdDescription = datastore.query().target(TARGET).stream(ID, DESCRIPTION);

  assertEquals(2, productIdDescription.count());

  // get the products with a price greater then 11
  List<PropertyBox> products = datastore.query().target(TARGET).filter(UNIT_PRICE.gt(11.00)).list(PRODUCT);

  assertEquals(1, products.size());
  assertEquals(Long.valueOf(2), products.get(0).getValue(ID));

  // get the products with a price greater then 11 and description starting with "The"
  products = datastore.query().target(TARGET).filter(UNIT_PRICE.gt(11.00).and(DESCRIPTION.startsWith("The")))
      .list(PRODUCT);
  assertEquals(1, products.size());

  // get the max price grouping by category
  Double maxPrice = datastore.query().target(TARGET).aggregate(CATEGORY).stream(UNIT_PRICE.max()).findFirst()
      .orElse(null);
  assertEquals(Double.valueOf(12.90), maxPrice);
}

public void testOperations() {

  // update the WITHDRAWN status for product 1
  datastore.query().target(TARGET).filter(ID.eq(1L)).findOne(PRODUCT).ifPresent(product -> {
    // update the product
    product.setValue(WITHDRAWN, true);
    datastore.update(TARGET, product);
  });

  assertTrue(datastore.query().target(TARGET).filter(ID.eq(1L)).findOne(WITHDRAWN).orElse(false));

  // insert a new product
  PropertyBox third = PropertyBox.builder(PRODUCT).set(SKU, "prod3-sku").set(DESCRIPTION, "The third product")
      .build();
  datastore.insert(TARGET, third, DefaultWriteOption.BRING_BACK_GENERATED_IDS);

  // remove the product
  OperationResult result = datastore.delete(TARGET, third);
  assertEquals(1, result.getAffectedCount());
}

public void testBulk() {

  // bulk update: update all the products with category C1 to category C2
  OperationResult result = datastore.bulkUpdate(TARGET).set(CATEGORY, "C2").filter(CATEGORY.eq("C1")).execute();

  assertEquals(2, result.getAffectedCount());

  // bulk delete: delete all the products with category C2
  result = datastore.bulkDelete(TARGET).filter(CATEGORY.eq("C2")).execute();

  assertEquals(2, result.getAffectedCount());
}

@Test
public void testDatastore() {
  testSave();
  testQuery();
  testOperations();
  testBulk();
}

<dependency>
  <groupId>com.holon-platform.jdbc</groupId>
  <artifactId>holon-starter-jdbc-datastore-hikaricp</artifactId>
</dependency>

create table products (
  id bigint primary key auto_increment,
  sku varchar(100) not null,
  description varchar(500),
  category varchar(10),
  price double,
  withdrawn integer default 0
)

spring:
  datasource:
    url: "jdbc:h2:mem:test"
    username: "sa"

@Entity(name = "products") (1)
@Table(name = "products")
public class ProductEntity {

  @Id
  @GeneratedValue
  private Long id;

  private String sku;

  private String description;

  private String category;

  private Double price;

  private Integer withdrawn;

  public Long getId() {
    return id;
  }

  public void setId(Long id) {
    this.id = id;
  }

  public String getSku() {
    return sku;
  }

  public void setSku(String sku) {
    this.sku = sku;
  }

  public String getDescription() {
    return description;
  }

  public void setDescription(String description) {
    this.description = description;
  }

  public String getCategory() {
    return category;
  }

  public void setCategory(String category) {
    this.category = category;
  }

  public Double getPrice() {
    return price;
  }

  public void setPrice(Double price) {
    this.price = price;
  }

  public Integer getWithdrawn() {
    return withdrawn;
  }

  public void setWithdrawn(Integer withdrawn) {
    this.withdrawn = withdrawn;
  }

  // equals and hashCode omitted

}

<dependency>
  <groupId>com.holon-platform.jpa</groupId>
  <artifactId>holon-starter-jpa-hibernate</artifactId>
</dependency>