http://www.oracle.

com/technetwork/middleware/ias/toplink-jpa-
annotations-096251.html
• State may be “fetched
fetched”” as EAGER or LAZY
• LAZY – El contenedor difiere la carga hasta que el
campo o la colección es accesado
• EAGER – requiere que el campo o la relación sea
cargado cuando la entidad referenciadada es
cargada..
cargada
• CASCADA de operacioens entre entidades
relacionadas
• Se puede establecer cuando define la relación
• Configurable globalmente en archivo de mapeo

“Cascading” es utilizado para propagar el
efecto de una operación en todas las
entidades relacionadas
◦ Cascade = PERSIST
◦ Cascade = REMOVE
◦ Cascade = MERGE
◦ Cascade = REFRESH
◦ Cascade = ALL

Lenguaje de consulta, delete y update que
opera sobre entities

Similar a SQL pero no está orientado al
mundo relacional (tablas y columnas) sino al
mundo de objetos (entities y atributos)

Permite independizarse de la base de datos y
del esquema relacional

Permite la utilización de queries nativos en
SQL
• getResultList() – ejecuta un query y returna multiples
getResultList()
resultados
• getSingleResult()
getSingleResult () – ejecuta un query que retorna un único
resultado
• executeUpdate()
executeUpdate () – ejecuta un bulk update o delete
• setFirstResult()
setFirstResult () – establece el primer resultado a retornar
• setMaxResults()
setMaxResults () – establece el máximo numero de
resultados a devolver
• setParameter()
setParameter () – asocia un valor al parametro con nombre
o en el parametro de la posicion indicada
• setHint()
setHint () – aplica un consejo especifico del proveedor de
persistencia
• setFlushMode()
setFlushMode () – aplica el modo flush al query cuanto este
se ejecuta
ejecuta..

EntityManager provee el método find para localizar
entities, de la forma:

public <T> T find(Class<T> entityClass,

Object primaryKey);

Pero cuando se requiere flexibilidad de búsqueda

de entities, más allá de sus PKs es necesario definir
queries

Existen 2 tipos de queries
◦ Dinámicos
◦ Estáticos

Un query puede parametrizarse mediante 2 tipos de
parámetros:
◦ Posicionales
◦ Por nombre

Implican el uso de una cláusula WHERE

Además la interfaz Query provee métodos para paginar
consultas que devuelven colecciones de entities

Se definen al momento de utilizarlos

No están pensados para ser reusados

Los construye “on the fly” el EntityManager

Se los puede definir usando JPQL o SQL nativo
(en este caso llamando al método
createNativeQuery(…))
@PersistentContext em;
...
public List findAllEmployees() {
Query query = em.createQuery("SELECT e FROM Employee e");
return query.getResultList();
}
Build and execute queries dynamically at runtime.
public List findWithName (String name) {
return em.CreateQuery (
“SELECT c FROM Customer c ” +
“WHERE c.name LIKE :custName”)
.setParameter(“custName”, name)
.setMaxResults(10)
.getResultList();
}

Se definen para ser reusados

Declarados en 2 posibles lugares: sobre el
entity o en un archivo XML

Favorecen la mantenibilidad del código

Pueden aumentar la performance ya que se
preparan una sola vez y luego se reusan
cada vez que son llamados

Definidos con metadatos de lenguaje de
java o XML

Annotations: @NamedQuery,
@NamedNativeQuery

Sedefinen de la siguiente
forma:
@Entity
@NamedQueries({
@NamedQuery(
name = "findAllEmployees",
query = "SELECT e FROM Employee e"
),
@NamedQuery(
name = "findAllEmployeesSorted",
query = " SELECT e FROM Employee e ORDER BY e.name"
)
})
@Table(name = "EMPLOYEES")
public class Empleado implements Serializable
{
...
}
@NamedQuery(
name=“findCustomersByName”,
queryString=“SELECT c FROM Customer c ” +
“WHERE c.name LIKE :custName”
)

@PersistenceContext public EntityManager em;

List customers =
em.createNamedQuery(“findCustomersByName”).
setParameter(“custName”,
“smith”).getResultList();

vacio String
em.createQuery("");

Clase desconocida
em.createQuery("from IncorrectClassName");

“Obtener Todo“
Todo“
em.createQuery("from
Alumno").getResultList();

No puede obtener un alumno si la tabla esta vacia
em.createQuery("from Alumno").getSingleResult();

Obtener un simple objeto

Previament se inserto un alumno(existe un alumno en la tabla)

Final Alumno a = (Alumno) em.createQuery("from
Alumno").getSingleResult();

No puede obtenerse un simple objeto si tiene mas registros

em.createQuery("from Alumno").getSingleResult();

Buscando por pk
final Alumno a = em.find(Alumno.class,
alumnoregistrado.getId());

Porque no funciona este query?
Alumno a = em.find(Alumno.class, -42);

Busqueda con parametros

final List<Alumno> list = em.createQuery( "from Alumno where
nombre = ?1").setParameter(1, “Adalberto") .getResultList();

Devolviendo objetos iguales.

iguales.
Alumno pByKey = em.find(Alumno.class, alumno.getId());
Alumno pByWhere = (Alumno) em.createQuery( "SELECT a from
Alumno a where name=‘Yolanda'") .getSingleResult();

Porque no funcionan estos querys?

querys?

em.createQuery("from Alumnos").getSingleResult();

em.createQuery("from Alumno a where a.Nombres='Bratt'");

Usando el nombre del campo

em.createQuery("from Alumno a where
a.nombre='Brett'").getResultList();

¿Cómo funciona este query?
em.createQuery("from Alumno a where
a.nombre=‘Luis'").setParameter(1, “Luis");

¿Pórque no funciona?
em.createQuery("from Alumno a where
a.nombre=?1").setParameter(0, "Brett");

Utilizando un parametro de posicion

em.createQuery("from Alumno a where
a.nombre='?1'").setParameter(1, "Brett");

Adicione querys estaticos para las entidades
alumno y curso

Ejecute los querys como testq1

Adicione querys dinámicos para obtener la
siguiente información.

Total de Cursos que incluyen la palabra “Java”

Primer Curso del listado anterior

Listado de Alumnos con Nombre que termina
con “a”