Interface TransientAttributeDefinition<T>

Type Parameters:
T - the attribute value type
All Superinterfaces:
AttributeDefinition<T>, ValueAttributeDefinition<T>

public sealed interface TransientAttributeDefinition<T> extends ValueAttributeDefinition<T>
An attribute that does not map to an underlying database column.

TransientAttributeDefinition extends ValueAttributeDefinition for attributes used for temporary data, UI state, calculated values, or any other data that should not be persisted to the database. They are initialized to null when entities are loaded and ignored during DML operations.

The value of transient attributes can be set and retrieved like normal attributes but are ignored during insert, update, and delete operations. Setting a transient value therefore does not mark the entity as modified, unless the attribute is configured to, for one standing for something a custom persistence stores by other means, see TransientAttributeDefinition.Builder.modifies(boolean).

Transient attributes are useful for UI state, temporary calculations and values the record carries without storing. They are editable fields wherever the framework builds components from attribute definitions, which is what makes them the way a form holds something the table does not store:

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

  // Database columns
  Column<Long> ID = TYPE.longColumn("id");
  Column<String> FIRSTNAME = TYPE.stringColumn("firstname");
  Column<String> LASTNAME = TYPE.stringColumn("lastname");

  // Transient attributes
  Attribute<Boolean> SELECTED = TYPE.booleanAttribute("selected");
  Attribute<String> NOTES = TYPE.stringAttribute("notes");
}

EntityDefinition customer() {
  return Customer.TYPE.as()
          .attributes(
                  // Database columns
                  Customer.ID.as()
                          .primaryKey(),
                  Customer.FIRSTNAME.as()
                          .column()
                          .caption("First name"),
                  Customer.LASTNAME.as()
                          .column()
                          .caption("Last name"),

                  // UI state, not marking the entity modified
                  Customer.SELECTED.as()
                          .attribute()
                          .defaultValue(false)
                          .caption("Selected"),

                  // Notes a custom persistence stores elsewhere
                  Customer.NOTES.as()
                          .attribute()
                          .modifies(true) // Marks the entity as modified
                          .caption("Notes"))
          .build();
}

void customers(EntityConnection connection) {
  // Transient attributes are initialized to null when entities are loaded
  Entity customer = connection.selectSingle(Customer.ID.equalTo(1L));

  customer.set(Customer.SELECTED, true);
  customer.modified(); // false, SELECTED doesn't modify the entity

  customer.set(Customer.NOTES, "Important customer");
  customer.modified(); // true, NOTES modifies the entity

  // Transient attributes are ignored by the default persistence, which
  // throws when updating an entity with only transient values modified
}
See Also: