Java Persistence

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Entity {
    String name() default "";
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Table {
    String name() default "";
    String catalog() default "";
    String schema() default "";
    UniqueConstraint[] uniqueConstraints() default {};
    Index[] indexes() default {};
}

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Id;

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface GeneratedValue {
    GenerationType strategy() default GenerationType.AUTO;
    String generator() default "";
}

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
    String name() default "";
    boolean unique() default false;
    boolean nullable() default true;
    boolean insertable() default true;
    boolean updatable() default true;
    String columnDefinition() default "";
    String table() default "";
    int length() default 255;
    int precision() default 0;
    int scale() default 0;
}

public interface EntityManager extends AutoCloseable {
    void persist(Object entity);
    <T> T merge(T entity);
    void remove(Object entity);
    <T> T find(Class<T> entityClass, Object primaryKey);
    <T> T find(Class<T> entityClass, Object primaryKey, Map<String, Object> properties);
    <T> T find(Class<T> entityClass, Object primaryKey, LockModeType lockMode);
    <T> T find(Class<T> entityClass, Object primaryKey, LockModeType lockMode, Map<String, Object> properties);
    <T> T getReference(Class<T> entityClass, Object primaryKey);
    void flush();
    void setFlushMode(FlushModeType flushMode);
    FlushModeType getFlushMode();
    void lock(Object entity, LockModeType lockMode);
    void lock(Object entity, LockModeType lockMode, Map<String, Object> properties);
    void refresh(Object entity);
    void refresh(Object entity, Map<String, Object> properties);
    void refresh(Object entity, LockModeType lockMode);
    void refresh(Object entity, LockModeType lockMode, Map<String, Object> properties);
    void clear();
    void detach(Object entity);
    boolean contains(Object entity);
    LockModeType getLockMode(Object entity);
    void setProperty(String propertyName, Object value);
    Map<String, Object> getProperties();
    Query createQuery(String qlString);
    <T> TypedQuery<T> createQuery(CriteriaQuery<T> criteriaQuery);
    Query createQuery(CriteriaUpdate updateQuery);
    Query createQuery(CriteriaDelete deleteQuery);
    <T> TypedQuery<T> createQuery(String qlString, Class<T> resultClass);
    Query createNamedQuery(String name);
    <T> TypedQuery<T> createNamedQuery(String name, Class<T> resultClass);
    Query createNativeQuery(String sqlString);
    Query createNativeQuery(String sqlString, Class resultClass);
    Query createNativeQuery(String sqlString, String resultSetMapping);
    StoredProcedureQuery createNamedStoredProcedureQuery(String name);
    StoredProcedureQuery createStoredProcedureQuery(String procedureName);
    StoredProcedureQuery createStoredProcedureQuery(String procedureName, Class... resultClasses);
    StoredProcedureQuery createStoredProcedureQuery(String procedureName, String... resultSetMappings);
    void joinTransaction();
    boolean isJoinedToTransaction();
    <T> T unwrap(Class<T> cls);
    Object getDelegate();
    void close();
    boolean isOpen();
    EntityTransaction getTransaction();
    EntityManagerFactory getEntityManagerFactory();
    CriteriaBuilder getCriteriaBuilder();
    Metamodel getMetamodel();
    <T> EntityGraph<T> createEntityGraph(Class<T> rootType);
    EntityGraph<?> createEntityGraph(String graphName);
    EntityGraph<?> getEntityGraph(String graphName);
    <T> List<EntityGraph<? super T>> getEntityGraphs(Class<T> entityClass);
}

public interface EntityManagerFactory extends AutoCloseable {
    EntityManager createEntityManager();
    EntityManager createEntityManager(Map map);
    EntityManager createEntityManager(SynchronizationType synchronizationType);
    EntityManager createEntityManager(SynchronizationType synchronizationType, Map map);
    CriteriaBuilder getCriteriaBuilder();
    Metamodel getMetamodel();
    boolean isOpen();
    void close();
    Map<String, Object> getProperties();
    Cache getCache();
    PersistenceUnitUtil getPersistenceUnitUtil();
    void addNamedQuery(String name, Query query);
    <T> T unwrap(Class<T> cls);
    <T> void addNamedEntityGraph(String graphName, EntityGraph<T> entityGraph);
}

public class Persistence {
    public static EntityManagerFactory createEntityManagerFactory(String persistenceUnitName);
    public static EntityManagerFactory createEntityManagerFactory(String persistenceUnitName, Map map);
    public static PersistenceUtil getPersistenceUtil();
    public static void generateSchema(String persistenceUnitName, Map map);
}

public interface Query {
    List getResultList();
    Object getSingleResult();
    int executeUpdate();
    Query setMaxResults(int maxResult);
    int getMaxResults();
    Query setFirstResult(int startPosition);
    int getFirstResult();
    Query setHint(String hintName, Object value);
    Map<String, Object> getHints();
    <T> Query setParameter(Parameter<T> param, T value);
    Query setParameter(Parameter<Calendar> param, Calendar value, TemporalType temporalType);
    Query setParameter(Parameter<Date> param, Date value, TemporalType temporalType);
    Query setParameter(String name, Object value);
    Query setParameter(String name, Calendar value, TemporalType temporalType);
    Query setParameter(String name, Date value, TemporalType temporalType);
    Query setParameter(int position, Object value);
    Query setParameter(int position, Calendar value, TemporalType temporalType);
    Query setParameter(int position, Date value, TemporalType temporalType);
    Set<Parameter<?>> getParameters();
    Parameter<?> getParameter(String name);
    <T> Parameter<T> getParameter(String name, Class<T> type);
    Parameter<?> getParameter(int position);
    <T> Parameter<T> getParameter(int position, Class<T> type);
    boolean isBound(Parameter<?> param);
    <T> T getParameterValue(Parameter<T> param);
    Object getParameterValue(String name);
    Object getParameterValue(int position);
    Query setFlushMode(FlushModeType flushMode);
    FlushModeType getFlushMode();
    Query setLockMode(LockModeType lockMode);
    LockModeType getLockMode();
    <T> T unwrap(Class<T> cls);
}

public interface TypedQuery<X> extends Query {
    List<X> getResultList();
    X getSingleResult();
    TypedQuery<X> setMaxResults(int maxResult);
    TypedQuery<X> setFirstResult(int startPosition);
    TypedQuery<X> setHint(String hintName, Object value);
    <T> TypedQuery<X> setParameter(Parameter<T> param, T value);
    TypedQuery<X> setParameter(Parameter<Calendar> param, Calendar value, TemporalType temporalType);
    TypedQuery<X> setParameter(Parameter<Date> param, Date value, TemporalType temporalType);
    TypedQuery<X> setParameter(String name, Object value);
    TypedQuery<X> setParameter(String name, Calendar value, TemporalType temporalType);
    TypedQuery<X> setParameter(String name, Date value, TemporalType temporalType);
    TypedQuery<X> setParameter(int position, Object value);
    TypedQuery<X> setParameter(int position, Calendar value, TemporalType temporalType);
    TypedQuery<X> setParameter(int position, Date value, TemporalType temporalType);
    TypedQuery<X> setFlushMode(FlushModeType flushMode);
    TypedQuery<X> setLockMode(LockModeType lockMode);
}

public interface CriteriaBuilder {
    CriteriaQuery<Object> createQuery();
    <T> CriteriaQuery<T> createQuery(Class<T> resultClass);
    CriteriaQuery<Tuple> createTupleQuery();
    CriteriaUpdate<T> createCriteriaUpdate(Class<T> targetEntity);
    CriteriaDelete<T> createCriteriaDelete(Class<T> targetEntity);
    
    // Selection methods
    <Y> CompoundSelection<Y> construct(Class<Y> resultClass, Selection<?>... selections);
    CompoundSelection<Tuple> tuple(Selection<?>... selections);
    CompoundSelection<Object[]> array(Selection<?>... selections);
    
    // Predicate methods
    Predicate and(Expression<Boolean> x, Expression<Boolean> y);
    Predicate and(Predicate... restrictions);
    Predicate or(Expression<Boolean> x, Expression<Boolean> y);
    Predicate or(Predicate... restrictions);
    Predicate not(Expression<Boolean> restriction);
    Predicate conjunction();
    Predicate disjunction();
    Predicate isTrue(Expression<Boolean> x);
    Predicate isFalse(Expression<Boolean> x);
    Predicate isNull(Expression<?> x);
    Predicate isNotNull(Expression<?> x);
    Predicate equal(Expression<?> x, Expression<?> y);
    Predicate equal(Expression<?> x, Object y);
    Predicate notEqual(Expression<?> x, Expression<?> y);
    Predicate notEqual(Expression<?> x, Object y);
    
    // Comparison methods
    <Y extends Comparable<? super Y>> Predicate greaterThan(Expression<? extends Y> x, Expression<? extends Y> y);
    <Y extends Comparable<? super Y>> Predicate greaterThan(Expression<? extends Y> x, Y y);
    <Y extends Comparable<? super Y>> Predicate greaterThanOrEqualTo(Expression<? extends Y> x, Expression<? extends Y> y);
    <Y extends Comparable<? super Y>> Predicate greaterThanOrEqualTo(Expression<? extends Y> x, Y y);
    <Y extends Comparable<? super Y>> Predicate lessThan(Expression<? extends Y> x, Expression<? extends Y> y);
    <Y extends Comparable<? super Y>> Predicate lessThan(Expression<? extends Y> x, Y y);
    <Y extends Comparable<? super Y>> Predicate lessThanOrEqualTo(Expression<? extends Y> x, Expression<? extends Y> y);
    <Y extends Comparable<? super Y>> Predicate lessThanOrEqualTo(Expression<? extends Y> x, Y y);
    <Y extends Comparable<? super Y>> Predicate between(Expression<? extends Y> v, Expression<? extends Y> x, Expression<? extends Y> y);
    <Y extends Comparable<? super Y>> Predicate between(Expression<? extends Y> v, Y x, Y y);
    
    // String methods
    Predicate like(Expression<String> x, Expression<String> pattern);
    Predicate like(Expression<String> x, String pattern);
    Predicate like(Expression<String> x, Expression<String> pattern, Expression<Character> escapeChar);
    Predicate like(Expression<String> x, Expression<String> pattern, char escapeChar);
    Predicate like(Expression<String> x, String pattern, Expression<Character> escapeChar);
    Predicate like(Expression<String> x, String pattern, char escapeChar);
    Predicate notLike(Expression<String> x, Expression<String> pattern);
    Predicate notLike(Expression<String> x, String pattern);
    
    // Aggregate functions
    <N extends Number> Expression<N> sum(Expression<N> x);
    <N extends Number> Expression<N> prod(Expression<? extends N> x, Expression<? extends N> y);
    <N extends Number> Expression<N> prod(Expression<? extends N> x, N y);
    <N extends Number> Expression<N> prod(N x, Expression<? extends N> y);
    <N extends Number> Expression<N> diff(Expression<? extends N> x, Expression<? extends N> y);
    <N extends Number> Expression<N> diff(Expression<? extends N> x, N y);
    <N extends Number> Expression<N> diff(N x, Expression<? extends N> y);
    Expression<Number> sum(Expression<? extends Number> x, Expression<? extends Number> y);
    Expression<Number> sum(Expression<? extends Number> x, Number y);
    Expression<Number> sum(Number x, Expression<? extends Number> y);
    <N extends Number> Expression<Double> avg(Expression<N> x);
    <N extends Number> Expression<N> max(Expression<N> x);
    <N extends Number> Expression<N> min(Expression<N> x);
    <X extends Comparable<? super X>> Expression<X> greatest(Expression<X> x);
    <X extends Comparable<? super X>> Expression<X> least(Expression<X> x);
    Expression<Long> count(Expression<?> x);
    Expression<Long> countDistinct(Expression<?> x);
    
    // Ordering
    Order asc(Expression<?> x);
    Order desc(Expression<?> x);
}

public interface CriteriaQuery<T> extends AbstractQuery<T> {
    CriteriaQuery<T> select(Selection<? extends T> selection);
    CriteriaQuery<T> multiselect(Selection<?>... selections);
    CriteriaQuery<T> multiselect(List<Selection<?>> selectionList);
    <X> Root<X> from(Class<X> entityClass);
    <X> Root<X> from(EntityType<X> entity);
    CriteriaQuery<T> where(Expression<Boolean> restriction);
    CriteriaQuery<T> where(Predicate... restrictions);
    CriteriaQuery<T> groupBy(Expression<?>... grouping);
    CriteriaQuery<T> groupBy(List<Expression<?>> grouping);
    CriteriaQuery<T> having(Expression<Boolean> restriction);
    CriteriaQuery<T> having(Predicate... restrictions);
    CriteriaQuery<T> orderBy(Order... o);
    CriteriaQuery<T> orderBy(List<Order> o);
    CriteriaQuery<T> distinct(boolean distinct);
    List<Order> getOrderList();
    Set<ParameterExpression<?>> getParameters();
}

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface OneToOne {
    Class targetEntity() default void.class;
    CascadeType[] cascade() default {};
    FetchType fetch() default FetchType.EAGER;
    boolean optional() default true;
    String mappedBy() default "";
    boolean orphanRemoval() default false;
}

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface OneToMany {
    Class targetEntity() default void.class;
    CascadeType[] cascade() default {};
    FetchType fetch() default FetchType.LAZY;
    String mappedBy() default "";
    boolean orphanRemoval() default false;
}

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ManyToOne {
    Class targetEntity() default void.class;
    CascadeType[] cascade() default {};
    FetchType fetch() default FetchType.EAGER;
    boolean optional() default true;
}

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ManyToMany {
    Class targetEntity() default void.class;
    CascadeType[] cascade() default {};
    FetchType fetch() default FetchType.LAZY;
    String mappedBy() default "";
}

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface JoinColumn {
    String name() default "";
    String referencedColumnName() default "";
    boolean unique() default false;
    boolean nullable() default true;
    boolean insertable() default true;
    boolean updatable() default true;
    String columnDefinition() default "";
    String table() default "";
    ForeignKey foreignKey() default @ForeignKey(PROVIDER_DEFAULT);
}

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, length = 100)
    private String name;
    
    @Column(unique = true, nullable = false)
    private String email;
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Order> orders = new ArrayList<>();
    
    // Constructors, getters, and setters
    public User() {}
    
    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }
    
    // getters and setters omitted for brevity
}

@Stateless
public class UserService {
    
    @PersistenceContext
    private EntityManager em;
    
    public User create(User user) {
        em.persist(user);
        return user;
    }
    
    public User findById(Long id) {
        return em.find(User.class, id);
    }
    
    public List<User> findAll() {
        TypedQuery<User> query = em.createQuery("SELECT u FROM User u", User.class);
        return query.getResultList();
    }
    
    public List<User> findByName(String name) {
        TypedQuery<User> query = em.createQuery(
            "SELECT u FROM User u WHERE u.name LIKE :name", User.class);
        query.setParameter("name", "%" + name + "%");
        return query.getResultList();
    }
    
    public User update(User user) {
        return em.merge(user);
    }
    
    public void delete(User user) {
        if (em.contains(user)) {
            em.remove(user);
        } else {
            em.remove(em.merge(user));
        }
    }
}

public List<User> findUsersByCriteria(String namePattern, String email) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<User> query = cb.createQuery(User.class);
    Root<User> user = query.from(User.class);
    
    List<Predicate> predicates = new ArrayList<>();
    
    if (namePattern != null) {
        predicates.add(cb.like(user.get("name"), "%" + namePattern + "%"));
    }
    
    if (email != null) {
        predicates.add(cb.equal(user.get("email"), email));
    }
    
    query.where(predicates.toArray(new Predicate[0]));
    query.orderBy(cb.asc(user.get("name")));
    
    return em.createQuery(query).getResultList();
}