@Test
public void test_sql_custom_crud() {
Person _person =
doInJPA(
entityManager -> {
Person person = new Person();
person.setName("John Doe");
entityManager.persist(person);
return person;
});
doInJPA(
entityManager -> {
Long postId = _person.getId();
Person person = entityManager.find(Person.class, postId);
assertNotNull(person);
entityManager.remove(person);
});
doInJPA(
entityManager -> {
Long postId = _person.getId();
Person person = entityManager.find(Person.class, postId);
assertNull(person);
});
}
public int compare(Person p1, Person p2) {
int result = p2.getAge() - (p1.getAge());
if (0 == result) {
return p2.getId() - p1.getId(); // 若年龄相同则按id排序
}
return result;
}
@Test
public void testProxyMethod() {
Datastore ds = new RedisDatastore();
ds.getMappingContext().addPersistentEntity(Person.class);
Session conn = ds.connect();
Person p = new Person();
p.setName("Bob");
Address a = new Address();
a.setNumber("22");
a.setPostCode("308420");
p.setAddress(a);
conn.persist(p);
Person personProxy = (Person) conn.proxy(Person.class, p.getId());
EntityProxy proxy = (EntityProxy) personProxy;
assertFalse(proxy.isInitialized());
assertEquals(p.getId(), personProxy.getId());
assertFalse(proxy.isInitialized());
assertEquals("Bob", personProxy.getName());
assertTrue(proxy.isInitialized());
}
@Test
@Priority(10)
public void initData() {
EntityManager em = getOrCreateEntityManager();
try {
// Revision 1
em.getTransaction().begin();
NameInfo ni = new NameInfo("John", "Doe");
Person person1 = new Person("JDOE", ni);
em.persist(person1);
em.getTransaction().commit();
// Revision 2
em.getTransaction().begin();
person1 = em.find(Person.class, person1.getId());
person1.getNameInfo().setFirstName("Jane");
em.merge(person1);
em.getTransaction().commit();
// Revision 3
em.getTransaction().begin();
person1 = em.find(Person.class, person1.getId());
person1.setName("JDOE2");
em.merge(person1);
em.getTransaction().commit();
personId = person1.getId();
} finally {
em.close();
}
}
@Override
public int compare(Person o1, Person o2) {
int result = o2.getName().compareToIgnoreCase(o1.getName());
if (0 == result) {
return o1.getId() - o2.getId();
}
return result;
}
public void testCRUD() throws HibernateException, SQLException {
if (isUsingIdentity()) {
reportSkip("hand sql expecting non-identity id gen", "Custom SQL");
return;
}
Person p = new Person();
p.setName("Max");
p.setLastName("Andersen");
p.setNationalID("110974XYZ�");
p.setAddress("P. P. Street 8");
Session s = openSession();
s.save(p);
s.flush();
s.connection().commit();
s.close();
getSessions().evict(Person.class);
s = openSession();
Person p2 = (Person) s.get(Person.class, p.getId());
assertNotSame(p, p2);
assertEquals(p2.getId(), p.getId());
assertEquals(p2.getLastName(), p.getLastName());
s.flush();
List list = s.createQuery("select p from Party as p").list();
assertTrue(list.size() == 1);
s.connection().commit();
s.close();
s = openSession();
list = s.createQuery("select p from Person as p where p.address = 'L�rkev�nget 1'").list();
assertTrue(list.size() == 0);
p.setAddress("L�rkev�nget 1");
s.update(p);
list = s.createQuery("select p from Person as p where p.address = 'L�rkev�nget 1'").list();
assertTrue(list.size() == 1);
list = s.createQuery("select p from Party as p where p.address = 'P. P. Street 8'").list();
assertTrue(list.size() == 0);
s.delete(p);
list = s.createQuery("select p from Person as p").list();
assertTrue(list.size() == 0);
s.connection().commit();
s.close();
}
/**
* ajout des personnes dans la liste de ceux qui ont vu le film
*
* @param person personne à ajouter
* @throws UniqueException si personne déjà dans la liste
*/
public void addPerson(final Person person) throws UniqueException {
if (people.containsKey(person.getId())) {
throw new UniqueException("Cette personne à déjà vu ce film.");
}
people.put(person.getId(), person);
try {
person.addMovie(this);
} catch (UniqueException ex) {
}
}
@Test
public void testBasicOps() {
Session session = openSession();
session.beginTransaction();
Country country = new Country("US", "United States of America");
session.persist(country);
Person person = new Person("Steve", new Address());
person.getAddress().setLine1("123 Main");
person.getAddress().setCity("Anywhere");
person.getAddress().setCountry(country);
person.getAddress().setPostalCode("123456789");
session.persist(person);
session.getTransaction().commit();
session.close();
session = openSession();
session.beginTransaction();
session.createQuery("from Person p where p.address.country.iso2 = 'US'").list();
// same query!
session.createQuery("from Person p where p.address.country.id = 'US'").list();
person = (Person) session.load(Person.class, person.getId());
session.delete(person);
List countries = session.createQuery("from Country").list();
assertEquals(1, countries.size());
session.delete(countries.get(0));
session.getTransaction().commit();
session.close();
}
@Test
@Priority(10)
public void initData() {
Session session = openSession();
// Rev 1
session.getTransaction().begin();
Person p = new Person();
Name n = new Name();
n.setName("name1");
p.getNames().add(n);
session.saveOrUpdate(p);
session.getTransaction().commit();
// Rev 2
session.getTransaction().begin();
n.setName("Changed name");
session.saveOrUpdate(p);
session.getTransaction().commit();
// Rev 3
session.getTransaction().begin();
Name n2 = new Name();
n2.setName("name2");
p.getNames().add(n2);
session.getTransaction().commit();
personId = p.getId();
}
@Test
public void testLazyLoadedOneToOne() {
Datastore ds = new RedisDatastore();
ds.getMappingContext().addPersistentEntity(Person.class);
Session conn = ds.connect();
Person p = new Person();
p.setName("Bob");
Address a = new Address();
a.setNumber("22");
a.setPostCode("308420");
p.setAddress(a);
conn.persist(p);
p = (Person) conn.retrieve(Person.class, p.getId());
Address proxy = p.getAddress();
assertTrue(proxy instanceof javassist.util.proxy.ProxyObject);
assertTrue(proxy instanceof EntityProxy);
EntityProxy ep = (EntityProxy) proxy;
assertFalse(ep.isInitialized());
assertEquals(a.getId(), proxy.getId());
assertFalse(ep.isInitialized());
assertEquals("22", a.getNumber());
}
@Override
public Set<Person> getSiblingsAll(Person thisPerson) {
// return full and half siblings of thisPerson
// exclude thisPerson from the set
Set<Person> siblings = new HashSet<Person>();
List<Person> parents = new ArrayList<Person>();
em.getTransaction().begin();
Query q =
em.createQuery(
"select b.parents from Birth b, IN(b.person) p WHERE p.id = :personId"
+ " or p.id = :parent2Id");
q.setParameter("personId", thisPerson.getId());
parents.addAll((Collection<? extends Person>) q.getResultList());
if (!parents.isEmpty()) {
if (parents.size() == 2) {
siblings = getChildrenAll(parents.get(0), parents.get(1));
} else if (parents.size() == 1) {
siblings = getChildren(parents.get(0));
}
}
em.getTransaction().commit();
siblings.remove(thisPerson);
return siblings;
}
@Override
public List<Event> getChildrenBirths(Person person) {
// get the birth records of the children of this parent
List<Birth> birthRecords = new ArrayList<Birth>();
em.getTransaction().begin();
Query q = em.createQuery("select b from Birth b, IN(b.parents) p WHERE p.id = :idParam");
q.setParameter("idParam", person.getId());
birthRecords.addAll((Collection<? extends Birth>) q.getResultList());
List<Event> childrenBirths = new ArrayList<Event>();
for (Birth b : birthRecords) {
if (b != null) {
ChildRecord cr = new ChildRecord();
cr.setEventDate(b.getEventDate());
cr.setPerson(person);
cr.setChild(b.getPerson());
cr.setTown(b.getTown());
cr.setState_province(b.getState_province());
cr.setCountry(b.getCountry());
childrenBirths.add(cr);
}
}
em.getTransaction().commit();
return childrenBirths;
}
@Override
public List<Event> getChildAdoptionRecords(Person person) {
// get the birth records of the children of this parent
List<Adoption> adoptionRecords = new ArrayList<Adoption>();
em.getTransaction().begin();
TypedQuery<Adoption> q =
em.createQuery(
"select b from Adoption b, IN(b.parents) p WHERE p.id = :idParam", Adoption.class);
q.setParameter("idParam", person.getId());
adoptionRecords.addAll(q.getResultList());
List<Event> adoptions = new ArrayList<Event>();
for (Adoption b : adoptionRecords) {
if (b != null) {
AdoptedChildRecord cr = new AdoptedChildRecord();
cr.setEventDate(b.getEventDate());
cr.setPerson(person);
cr.setChild(b.getPerson());
cr.setTown(b.getTown());
cr.setState_province(b.getState_province());
cr.setCountry(b.getCountry());
adoptions.add(cr);
}
}
em.getTransaction().commit();
return adoptions;
}
@BeforeClass(dependsOnMethods = "init")
public void initData() {
newSessionFactory();
// Rev 1
getSession().getTransaction().begin();
Person p = new Person();
Name n = new Name();
n.setName("name1");
p.getNames().add(n);
getSession().saveOrUpdate(p);
getSession().getTransaction().commit();
// Rev 2
getSession().getTransaction().begin();
n.setName("Changed name");
getSession().saveOrUpdate(p);
getSession().getTransaction().commit();
// Rev 3
getSession().getTransaction().begin();
Name n2 = new Name();
n2.setName("name2");
p.getNames().add(n2);
getSession().getTransaction().commit();
personId = p.getId();
}
private Document createDocument(Person person) {
Document doc = new Document();
doc.add(new Field("id", person.getId(), Store.YES, Index.NOT_ANALYZED));
doc.add(new Field("name", person.getName(), Store.YES, Index.NOT_ANALYZED));
doc.add(
new Field("birthDate", person.getBirthDate().toString(), Store.YES, Index.NOT_ANALYZED));
return doc;
}
@Override
public String getAsText() {
Person p = (Person) getValue();
if (p == null) {
return "0";
}
return Integer.toString(p.getId());
}
@Test
public void _2_load() {
Account account = em().find(Account.class, 1l);
Person person = account.getPerson();
assertThat(person.getId()).isNotNull();
assertThat(person.getName()).isEqualTo("Augusto");
}
@End
public String createNewPerson(Issue issue23, java.util.Set<Person> assigned3) {
Person var74 = new Person();
Person person413 = var74;
assigned3.add(person413);
em.persist(issue23);
return "/" + "editPerson" + ".seam?" + ("person" + "=" + person413.getId() + "");
}
@Override
public Set<Person> getChildrenAll(Person parent1, Person parent2) {
// get the children of either parents
// look in the birth table and find person objects
// match both parents' ids in birth.parents
Set<Person> children = new HashSet<Person>();
em.getTransaction().begin();
Query q =
em.createQuery(
"select b.person from Birth b, IN(b.parents) p WHERE p.id = :parent1Id"
+ " or p.id = :parent2Id");
q.setParameter("parent1Id", parent1.getId()).setParameter("parent2Id", parent2.getId());
children.addAll((Collection<? extends Person>) q.getResultList());
em.getTransaction().commit();
return children;
}
@Factory("person181List")
public void initPerson181List() {
log.info("initPerson181List");
person181List = new HashMap<String, String>();
for (Object o : em.createQuery("from " + "Person").getResultList()) {
Person p = (Person) o;
person181List.put(p.getName(), p.getId().toString());
}
}
public void delete(Person person) throws DAOException {
PreparedStatement pstmt;
try {
pstmt = getConnection().prepareStatement("DELETE FROM PERSON WHERE PERSON.id = ?");
execute(pstmt, person.getId());
} catch (SQLException ex) {
throw new DAOException(ex);
}
}
public void updateLastName(Person person) throws DAOException {
PreparedStatement pstmt;
try {
pstmt = getConnection().prepareStatement("UPDATE Person set Lastname = ? WHERE id = ?");
} catch (SQLException ex) {
throw new DAOException(ex);
}
execute(pstmt, person.getLastName(), person.getId());
}
private void addAndRetrievePerson(MongoTemplate template) {
Person person = new Person("Oliver");
person.setAge(25);
template.insert(person);
Person result = template.findById(person.getId(), Person.class);
assertThat(result.getFirstName(), is("Oliver"));
assertThat(result.getAge(), is(25));
}
/**
* Move one Sor Record from one person to another.
*
* @param fromPerson person losing sor record.
* @param toPerson person receiving sor record.
* @return Success or failure.
*/
public boolean moveSystemOfRecordPerson(
Person fromPerson, Person toPerson, SorPerson movingSorPerson) {
movingSorPerson.setPersonId(toPerson.getId());
updateCalculatedPersonsOnMoveOfSor(toPerson, fromPerson, movingSorPerson);
this.personRepository.savePerson(fromPerson);
this.personRepository.savePerson(toPerson);
this.personRepository.saveSorPerson(movingSorPerson);
return true;
}
@Override
public void cascadeDelete(Person p) throws MapperException {
List<Person> people = PersonInputMapper.findAll();
for (Person person : people) {
IPerson buddy = person.getBuddy();
if (buddy == null || buddy.getId() != p.getId()) continue;
delete(person);
}
}
@Override
public void insert(Person p) throws MapperException {
Long buddyId = p.getBuddy() == null ? null : p.getBuddy().getId();
try {
PersonTDG.insert(p.getId(), p.getVersion(), p.getName(), p.getAge(), buddyId);
} catch (SQLException e) {
throw new MapperException(e);
}
}
public void update(Person person) {
SQLiteDatabase db = dbOpenHelper.getWritableDatabase();
ContentValues values = new ContentValues();
values.put("name", person.getName());
values.put("phone", person.getPhone());
db.update("person", values, "personid=?", new String[] {person.getId().toString()});
}
@Test
public void Populate() {
QPerson person = QPerson.person;
QBean<Person> personProjection =
new QBean<Person>(Person.class, person.id, person.firstname, person.securedid);
Person p = personProjection.newInstance(3, "X", "Y");
assertEquals(3, p.getId());
assertEquals("X", p.getFirstname());
assertEquals("Y", p.getSecuredid());
}
@Override
public Adoption findAdoptionRecord(Person person) {
// Could be null
em.getTransaction().begin();
Query q = em.createQuery("select a from Adoption a WHERE a.person.id = :idParam");
q.setParameter("idParam", person.getId());
List<Adoption> results = (List<Adoption>) q.getResultList();
em.getTransaction().commit();
return (results != null && results.size() > 0) ? results.get(0) : null;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof Person) {
Person p = (Person) obj;
if (p.getId() == getId()) {
return true;
}
}
return false;
}
