Quickstart

create user if not exists scott password 'tiger';
alter user scott admin true;

create schema store;

create table store.customer (
  id varchar(36) not null,
  first_name varchar(40) not null,
  last_name varchar(40) not null,
  email varchar(100),
  active boolean default true not null,
  constraint customer_pk primary key (id),
  constraint customer_email_uk unique (email)
);

create table store.address (
  id identity not null,
  street varchar(120) not null,
  city varchar(50) not null,
  valid boolean default true not null,
  constraint address_pk primary key (id),
  constraint address_uk unique (street, city)
);

create table store.customer_address (
  id identity not null,
  customer_id varchar(36) not null,
  address_id integer not null,
  constraint customer_address_pk primary key (id),
  constraint customer_address_uk unique (customer_id, address_id)
);

insert into store.customer(id, first_name, last_name, email)
values ('ff60ebc3-bae0-4c0f-b094-4129edd3665a', 'John', 'Doe', 'doe@doe.net');

insert into store.address(street, city)
values ('Elm Street 123', 'Syracuse');

insert into store.customer_address(customer_id, address_id)
values ('ff60ebc3-bae0-4c0f-b094-4129edd3665a', 1);

commit;

public class Store extends DomainModel {

  public static final DomainType DOMAIN = domainType(Store.class);

  public Store() {
    super(DOMAIN);
    add(customer(), address(), customerAddress());
  }

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

  EntityDefinition customer() {
    return Customer.TYPE.define(
                    Customer.ID.define()
                            .primaryKey(),
                    Customer.FIRST_NAME.define()
                            .column()
                            .caption("First name")
                            .nullable(false)
                            .maximumLength(40),
                    Customer.LAST_NAME.define()
                            .column()
                            .caption("Last name")
                            .nullable(false)
                            .maximumLength(40))
            .keyGenerator(identity())
            .stringFactory(StringFactory.builder()
                    .value(Customer.LAST_NAME)
                    .text(", ")
                    .value(Customer.FIRST_NAME)
                    .build())
            .build();
  }

  public interface Address {
    EntityType TYPE = DOMAIN.entityType("store.address");

    Column<Integer> ID = TYPE.integerColumn("id");
    Column<String> STREET = TYPE.stringColumn("street");
    Column<String> CITY = TYPE.stringColumn("city");
  }

  EntityDefinition address() {
    return Address.TYPE.define(
                    Address.ID.define()
                            .primaryKey(),
                    Address.STREET.define()
                            .column()
                            .caption("Street")
                            .nullable(false)
                            .maximumLength(120),
                    Address.CITY.define()
                            .column()
                            .caption("City")
                            .nullable(false)
                            .maximumLength(50))
            .keyGenerator(automatic("store.address"))
            .stringFactory(StringFactory.builder()
                    .value(Address.STREET)
                    .text(", ")
                    .value(Address.CITY)
                    .build())
            .build();
  }

  public interface CustomerAddress {
    EntityType TYPE = DOMAIN.entityType("store.customer_address");

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

    ForeignKey CUSTOMER_FK = TYPE.foreignKey("customer_fk", CUSTOMER_ID, Customer.ID);
    ForeignKey ADDRESS_FK = TYPE.foreignKey("address_fk", ADDRESS_ID, Address.ID);
  }

  EntityDefinition customerAddress() {
    return CustomerAddress.TYPE.define(
                    CustomerAddress.ID.define()
                            .primaryKey(),
                    CustomerAddress.CUSTOMER_ID.define()
                            .column()
                            .nullable(false),
                    CustomerAddress.CUSTOMER_FK.define()
                            .foreignKey()
                            .caption("Customer"),
                    CustomerAddress.ADDRESS_ID.define()
                            .column()
                            .nullable(false),
                    CustomerAddress.ADDRESS_FK.define()
                            .foreignKey()
                            .caption("Address"))
            .keyGenerator(automatic("store.customer_address"))
            .caption("Customer address")
            .build();
  }
}

/*
 * This file is part of Codion.
 *
 * Codion is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Codion is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Codion.  If not, see <https://www.gnu.org/licenses/>.
 *
 * Copyright (c) 2004 - 2025, Björn Darri Sigurðsson.
 */
package is.codion.manual.quickstart;

import is.codion.common.db.database.Database;
import is.codion.common.user.User;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.db.local.LocalEntityConnection;
import is.codion.framework.db.local.LocalEntityConnectionProvider;
import is.codion.framework.domain.entity.Entities;
import is.codion.framework.domain.entity.Entity;
import is.codion.swing.common.ui.dialog.Dialogs;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.model.SwingEntityModel;
import is.codion.swing.framework.ui.EntityEditPanel;
import is.codion.swing.framework.ui.EntityPanel;

import java.util.List;

import static is.codion.manual.quickstart.Store.*;

public final class Example {

  public class CustomerEditPanel extends EntityEditPanel {

    public CustomerEditPanel(SwingEntityEditModel editModel) {
      super(editModel);
    }

    @Override
    protected void initializeUI() {
      focus().initial().set(Customer.FIRST_NAME);
      createTextField(Customer.FIRST_NAME);
      createTextField(Customer.LAST_NAME);
      addInputPanel(Customer.FIRST_NAME);
      addInputPanel(Customer.LAST_NAME);
    }
  }

  public class AddressEditPanel extends EntityEditPanel {

    public AddressEditPanel(SwingEntityEditModel editModel) {
      super(editModel);
    }

    @Override
    protected void initializeUI() {
      focus().initial().set(CustomerAddress.CUSTOMER_FK);
      createComboBox(CustomerAddress.CUSTOMER_FK);
      createComboBox(CustomerAddress.ADDRESS_FK);
      addInputPanel(CustomerAddress.CUSTOMER_FK);
      addInputPanel(CustomerAddress.ADDRESS_FK);
    }
  }

  void customerPanel() {
    EntityConnectionProvider connectionProvider =
            LocalEntityConnectionProvider.builder()
                    .domain(new Store())
                    .user(User.parse("scott:tiger"))
                    .build();

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

    CustomerEditPanel customerEditPanel =
            new CustomerEditPanel(customerModel.editModel());

    EntityPanel customerPanel =
            new EntityPanel(customerModel, customerEditPanel);

    SwingEntityModel addressModel =
            new SwingEntityModel(CustomerAddress.TYPE, connectionProvider);

    customerModel.detailModels().add(addressModel);

    AddressEditPanel addressEditPanel =
            new AddressEditPanel(addressModel.editModel());

    EntityPanel addressPanel =
            new EntityPanel(addressModel, addressEditPanel);

    customerPanel.detailPanels().add(addressPanel);

    //lazy initialization of UI components
    customerPanel.initialize();

    //populate the table model with data from the database
    customerModel.tableModel().items().refresh();

    Dialogs.componentDialog(customerPanel)
            .title("Customers")
            .show();
  }

  void selectEntities() {
    Store domain = new Store();

    EntityConnection connection =
            LocalEntityConnection.localEntityConnection(
                    Database.instance(), domain, User.parse("scott:tiger"));

    //select customer
    Entity johnDoe = // where last name = Doe
            connection.selectSingle(Customer.LAST_NAME.equalTo("Doe"));

    //select all customer addresses
    List<Entity> customerAddresses = //where customer = john doe
            connection.select(CustomerAddress.CUSTOMER_FK.equalTo(johnDoe));

    Entity customerAddress = customerAddresses.get(0);

    Entity address = customerAddress.entity(CustomerAddress.ADDRESS_FK);

    String lastName = johnDoe.get(Customer.LAST_NAME);
    String street = address.get(Address.STREET);
    String city = address.get(Address.CITY);
  }

  void persistEntities() {
    Store domain = new Store();

    EntityConnection connection =
            LocalEntityConnection.localEntityConnection(
                    Database.instance(), domain, User.parse("scott:tiger"));

    Entities entities = domain.entities();

    Entity customer = entities.builder(Customer.TYPE)
            .with(Customer.FIRST_NAME, "John")
            .with(Customer.LAST_NAME, "Doe")
            .build();

    customer = connection.insertSelect(customer);

    Entity address = entities.builder(Address.TYPE)
            .with(Address.STREET, "Elm Street 321")
            .with(Address.CITY, "Syracuse")
            .build();

    address = connection.insertSelect(address);

    Entity customerAddress = entities.builder(CustomerAddress.TYPE)
            .with(CustomerAddress.CUSTOMER_FK, customer)
            .with(CustomerAddress.ADDRESS_FK, address)
            .build();

    customerAddress = connection.insertSelect(customerAddress);

    customer.put(Customer.FIRST_NAME, "Jonathan");

    connection.update(customer);

    connection.delete(customerAddress.primaryKey());
  }
}