The Seasar Project

package examples.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.OneToOne;
import javax.persistence.Version;

/**
 * Employeeエンティティクラス
 * 
 * @author S2JDBC-Gen
 */
@Entity
public class Employee {

    /** idプロパティ */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(nullable = false, unique = true)
    public Integer id;

    /** nameプロパティ */
    @Column(length = 255, nullable = false, unique = false)
    public String name;

    /** jobTypeプロパティ */
    @Column(nullable = false, unique = false)
    public Integer jobType;

    /** salaryプロパティ */
    @Column(nullable = true, unique = false)
    public Integer salary;

    /** departmentIdプロパティ */
    @Column(nullable = true, unique = false)
    public Integer departmentId;

    /** addressIdプロパティ */
    @Column(nullable = true, unique = true)
    public Integer addressId;

    /** versionプロパティ */
    @Version
    @Column(nullable = false, unique = false)
    public Integer version;

    /** address関連プロパティ */
    @OneToOne
    public Address address;

    /** department関連プロパティ */
    @ManyToOne
    public Department department;
}

package examples.entity;

public enum JobType {

    CLERK,
    SALESMAN,
    MANAGER,
    ANALYST,
    PRESIDENT;
}

@ManyToOne
public Department department;

@OneToMany(mappedBy = "department")
public List<Employee> employeeList;

@OneToOne
public Address address;

@OneToOne(mappedBy = "address")
public Employee employee;

package examples.entity;

import java.util.List;

import org.seasar.extension.jdbc.JdbcManager;
import org.seasar.extension.unit.S2TestCase;

public class GetResultListTest extends S2TestCase {

    private JdbcManager jdbcManager;

    protected void setUp() throws Exception {
        include("app.dicon");
    }

    public void testGetResultList() throws Exception {
        ...
    }
}

List<Employee> results =
    jdbcManager.from(Employee.class).getResultList();
for (Employee e : results) {
    System.out.println(e.name);
}

Employee result =
    jdbcManager
        .from(Employee.class)
        .where("id = ?", 1)
        .getSingleResult();
System.out.println(result.name);

where("id = ? or name = ?", 1, "SCOTT")

public void testIterate() throws Exception {
    long sum =
        jdbcManager.from(Employee.class).iterate(
            new IterationCallback<Employee, Long>() {
                private long sum;

                public Long iterate(Employee emp, IterationContext context) {
                    sum += emp.salary;
                    return sum;
                }
            });
    System.out.println(sum);
}

public void testIterateExit() throws Exception {
    Employee emp =
        jdbcManager.from(Employee.class).iterate(
            new IterationCallback<Employee, Employee>() {
                private long sum;

                public Employee iterate(Employee emp,
                        IterationContext context) {
                    sum += emp.salary;
                    if (sum > 10000) {
                        context.setExit(true);
                    }
                    return emp;
                }
            });
    System.out.println(emp.name);
}

public void testGetCount() throws Exception {
    long count = jdbcManager.from(Employee.class).getCount();
    System.out.println(count);
}

List<Employee> results =
    jdbcManager
        .from(Employee.class)
        .leftOuterJoin("department")
        .leftOuterJoin("address")
        .getResultList();
for (Employee e : results) {
    System.out.println(e.name
        + ", "
        + e.department.name
        + ", "
        + e.address.name);
}

List<Employee> results =
    jdbcManager
        .from(Employee.class)
        .leftOuterJoin("address")
        .where(
            new SimpleWhere().starts("name", "A").ends(
                "address.name",
                "1"))
        .getResultList();
for (Employee e : results) {
    System.out.println(e.name + ", " + e.address.name);
}

List<Employee> results =
    jdbcManager
        .from(Employee.class)
        .orderBy("name desc")
        .getResultList();
for (Employee e : results) {
    System.out.println(e.name);
}

List<Employee> results =
    jdbcManager
        .from(Employee.class)
        .orderBy("id")
        .limit(5)
        .offset(4)
        .getResultList();
for (Employee e : results) {
    System.out.println(e.id);
}

public void testInsertTx() throws Exception {
    Employee emp = new Employee();
    emp.name = "test";
    emp.jobType = JobType.ANALYST;
    emp.salary = 300;
    jdbcManager.insert(emp).execute();
    System.out.println(emp.id);
}

Employee emp =
    jdbcManager
        .from(Employee.class)
        .where("id = ?", 1)
        .getSingleResult();
emp.name = "hoge";
System.out.println(emp.version);
jdbcManager.update(emp).execute();
System.out.println(emp.version);

Employee emp =
    jdbcManager
        .from(Employee.class)
        .where("id = ?", 1)
        .getSingleResult();
jdbcManager.delete(emp).execute();
emp =
    jdbcManager
        .from(Employee.class)
        .where("id = ?", 1)
        .getSingleResult();
System.out.println(emp);

private static final String SELECT_EMPLOYEE_DTO =
    "select e.*, d.name as department_name"
        + " from employee e left outer join department d"
        + " on e.department_id = d.id"
        + " where d.id = ?";
...
List<EmployeeDto> results =
    jdbcManager
        .selectBySql(EmployeeDto.class, SELECT_EMPLOYEE_DTO, 1)
        .getResultList();
for (EmployeeDto e : results) {
    System.out.println(e.name + " " + e.departmentName);
}

selectBySql(EmployeeDto.class, "... id = ? or name = ?", 1, "SCOTT")

private static final String LABEL_VALUE =
    "select name as label, id as value from employee";
...
List<BeanMap> results =
    jdbcManager.selectBySql(BeanMap.class, LABEL_VALUE).getResultList();
for (BeanMap m : results) {
    System.out.println(m);
}

private static final String SELECT_COUNT = "select count(*) from employee";
...
Integer result =
    jdbcManager
        .selectBySql(Integer.class, SELECT_COUNT)
        .getSingleResult();
System.out.println(result);

select * from employee
where
salary >= 1000
and salary <= 2000

select * from employee
where
salary >= /*salaryMin*/1000
and salary <= 2000

select * from employee
where
salary >= /*salaryMin*/1000
and salary <= /*salaryMax*/2000

select * from employee
where
/*IF salaryMin != null*/
salary >= /*salaryMin*/1000
/*END*/
/*IF salaryMax != null*/
and salary <= /*salaryMax*/2000
/*END*/

select * from employee
where
salary >= ?

select * from employee
where
and salary <= ?

select * from employee
where

select * from employee
/*BEGIN*/
where
/*IF salaryMin != null*/
salary >= /*salaryMin*/1000
/*END*/
/*IF salaryMax != null*/
and salary <= /*salaryMax*/2000
/*END*/
/*END*/

select * from employee
where
salary <= ?

select * from employee

select e.*, d.name as department_name
from employee e left outer join department d on e.department_id = d.id
/*BEGIN*/
where
  /*IF salaryMin != null*/
    e.salary >= /*salaryMin*/1000
  /*END*/
  /*IF salaryMax != null*/
    and e.salary <= /*salaryMax*/2000
  /*END*/
/*END*/
order by e.salary

private static final String SQL_FILE =
    "examples/sql/employee/selectWithDepartment.sql";
...
SelectWithDepartmentDto dto = new SelectWithDepartmentDto();
dto.salaryMin = 1200;
dto.salaryMax = 1800;
List<EmployeeDto> results =
    jdbcManager
        .selectBySqlFile(EmployeeDto.class, SQL_FILE, dto)
        .getResultList();
for (EmployeeDto e : results) {
    System.out
        .println(e.name + " " + e.salary + " " + e.departmentName);
}

package examples.dto;

public class SelectWithDepartmentDto {

    public Integer salaryMin;

    public Integer salaryMax;
}

package examples.entity;

public enum JobType {

    CLERK {
        @Override
        public int calculateBonus(int salary) {
            return salary;
        }
    },
    SALESMAN {
        @Override
        public int calculateBonus(int salary) {
            return salary * 2;
        }
    },
    MANAGER {
        @Override
        public int calculateBonus(int salary) {
            return salary * 3;
        }
    },
    ANALYST {
        @Override
        public int calculateBonus(int salary) {
            return salary * 4;
        }
    },
    PRESIDENT {
        @Override
        public int calculateBonus(int salary) {
            return salary * 5;
        }
    };

    public abstract int calculateBonus(int salary);
}

List<Employee> results =
    jdbcManager.from(Employee.class).getResultList();
int totalBonus = 0;
for (Employee e : results) {
    totalBonus += e.jobType.calculateBonus(e.salary);
}
System.out.println("Total Bonus:" + totalBonus);