Having this two classes:
Address.java:
#Embeddable
#Data
#AllArgsConstructor
#NoArgsConstructor
#Builder
public class Address {
private String street;
private String city;
private String state;
private String pincode;
}
User.java:
#Entity
#Data
public class User {
#Id
private int id;
private String name;
#ElementCollection
private Set<Address> addresses = new HashSet<>();
}
DemoApplication.java:
#Bean
CommandLineRunner dataLoader2(UserRepository userRepo){
return new CommandLineRunner() {
#Override
public void run(String... args) throws Exception {
User u = new User();
u.setName("Some random name");
Address a1 = Address.builder()
.street("First Street")
.city("first city")
.state("first state")
.pincode("100001")
.build();
Address a2 = Address.builder()
.street("Second Street")
.city("Second city")
.state("second state")
.pincode("200002")
.build();
u.setAddresses(new HashSet<>(Arrays.asList(a1, a2)));
userRepo.save(u);
}
};
}
When run, if fails with this error:
GenerationTarget encountered exception accepting command : Error
executing DDL "alter table user_addresses drop foreign key
FKfm6x520mag23hvgr1oshaut8b" via JDBC Statement
Yet, the final tables are created:
describe user_addresses:
+---------+--------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+---------+--------------+------+-----+---------+-------+
| user_id | int | NO | MUL | NULL | |
| city | varchar(255) | YES | | NULL | |
| pincode | varchar(255) | YES | | NULL | |
| state | varchar(255) | YES | | NULL | |
| street | varchar(255) | YES | | NULL | |
+---------+--------------+------+-----+---------+-------+
describe user:
+-------+--------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+-------+
| id | int | NO | PRI | NULL | |
| name | varchar(255) | YES | | NULL | |
+-------+--------------+------+-----+---------+-------+
Why cannot the jdbc drop the foreign key user_id in table user_addresses? How to make the jdbc to do so?
"USER" is a reserved word in MySQL and that might be the root cause of the issue. Change the name of the User entity or add #Table annotation to it and define a different name.
Reference documentation:
https://dev.mysql.com/doc/refman/5.7/en/keywords.html
https://dev.mysql.com/doc/refman/8.0/en/keywords.html
Related
I am working on a Spring application that use JdbcTemplate to query the database, and the result from the rowmapper is different from the result of the query.
My query returns :
+--------------------+---------+------+------+----------+----------+----------+----------+---------+----------------+-----------------+
| ORIGINATING_SYSTEM | SYS_REF | CUR1 | CUR2 | TRADE_DT | START_DT | END_DT | BOOK_REF | BOOK_ID | NOMINAL | ORIGIN_VALUE_DT |
+--------------------+---------+------+------+----------+----------+----------+----------+---------+----------------+-----------------+
| CC | 4000000 | USD | | 01/04/19 | 01/04/19 | 01/04/19 | TDCZK | 317 | -8245872154,55 | 29/03/19 |
| GPS | 4000000 | EUR | | 01/04/19 | 28/03/19 | 28/03/19 | TDCZK | 317 | 55555550 | |
+--------------------+---------+------+------+----------+----------+----------+----------+---------+----------------+-----------------+
This result is processed with a rowmapper to get a list :
public List<Trade> findBackValueTrades() {
List<Trade> trades = getJdbcTemplate().query(FIND_BACK_VALUE_TRADES, new BackValueTradeMapper());
}
class BackValueTradeMapper implements RowMapper<Trade> {
public BackValueTradeMapper() {
}
#Override
public Trade mapRow(final ResultSet rs, final int rowNum) throws SQLException {
Trade trade = new Trade();
trade.setOriginatingSystem(rs.getString("ORIGINATING_SYSTEM"));
trade.setSystemRef(rs.getString("SYS_REF"));
trade.setNominal(rs.getDouble("NOMINAL"));
Currency cur1 = new Currency();
cur1.setId(rs.getString("CUR1"));
trade.setCurrency1(cur1);
Currency cur2 = new Currency();
cur2.setId(rs.getString("CUR2"));
trade.setCurrency2(cur2);
trade.setTradeDate(rs.getDate("TRADE_DT"));
trade.setStartDate(rs.getDate("START_DT"));
trade.setEndDate(rs.getDate("END_DT"));
Book book = new Book();
book.setBookRef(rs.getString("BOOK_REF"));
book.setId(rs.getLong("BOOK_ID"));
trade.setBook(book);
trade.setNominal(rs.getDouble("NOMINAL"));
trade.setEnteredDate(rs.getDate("ORIGIN_VALUE_DT"));
return trade;
}
}
where Trade is just an #Entity, containing only fields and getters and setters :
#Table(name = "TRADES")
#Entity
public class Trade implements Serializable {
private static final long serialVersionUID = 2143115773381859155L;
#Column(name = "ID")
#Id
private Long id;
#Column(name = "SYS_REF")
private String systemRef;
#Column(name = "ORIGINATING_SYSTEM")
private String originatingSystem;
#ManyToOne(fetch = FetchType.LAZY)
#JoinColumn(name = "CUR1")
private Currency cur1;
// remaining fields + getters/setters
}
The problem is in the resulting list, where it seems the trade from CC was overwritten :
+--------------------+---------+------+------+----------+----------+----------+----------+---------+-----------+-----------------+
| ORIGINATING_SYSTEM | SYS_REF | CUR1 | CUR2 | TRADE_DT | START_DT | END_DT | BOOK_REF | BOOK_ID | NOMINAL | ORIGIN_VALUE_DT |
+--------------------+---------+------+------+----------+----------+----------+----------+---------+-----------+-----------------+
| GPS | 4000000 | EUR | | 01/04/19 | 28/03/19 | 28/03/19 | TDCZK | 317 | 55555550 | 29/03/19 |
| GPS | 4000000 | EUR | | 01/04/19 | 28/03/19 | 28/03/19 | TDCZK | 317 | 55555550 | 28/03/19 |
+--------------------+---------+------+------+----------+----------+----------+----------+---------+-----------+-----------------+
Why is that ?
By the way, I was able to resolve the issue by extending the Trade class and overriding equals and hashCode, but I want to know why it worked.
The environment is Java, Spring-boot, Hibernat, QueryDSL, MySQL.
I have table structure
Episode
+----+-------------+--------
| id | address_id | eventno
+----+-------------+--------
| 5 | 27 | F123
| 6 | 30 | F456
| 7 | 45 | F789
+----+-------------+--------
#Entity
public class Episode {
#Id
#GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
#NotEmpty
private String eventno;
#ManyToOne(cascade = CascadeType.ALL)
private Address address;
Episode_Person
+----+--------------+--------------+------------+-----------+
| id | episode_role | primary_flag | episode_id | person_id |
+----+--------------+--------------+------------+-----------+
| 19 | Buyer | | 5 | 1 |
| 20 | Subject | | 5 | 2 |
| 23 | Witness | | 6 | 3 |
| 24 | Child | | 6 | 4 |
| 27 | Buyer | | 5 | 3 |
| 63 | Investor | | 5 | 4 |
| 64 | Subject | | 7 | 1 |
| 65 | Subject | | 7 | 3 |
#Entity
public class EpisodePerson {
#Id
#GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
#ManyToOne
#Valid
private Person person;
#ManyToOne
private Episode episode;
Person
+----+-----------+----------+
| id | firstname | surname |
+----+-----------+----------+
| 1 | Clint | eastwood |
| 2 | Angelina | joilee |
| 3 | Brad | pitt |
| 4 | Jennifer | aniston |
#Entity
#Table(uniqueConstraints = #UniqueConstraint(columnNames = {"nia"}))
public class Person {
#Id
#GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String surname;
private String firstname;
private String gender;
So each episode has multiple people. And the join table is Episode_Person.
My UI has a datatable with a filter on each column:
The filtering already works on Event and Address. And looks like this predicate in QueryDSL:
BooleanBuilder where = new BooleanBuilder();
if (pagination.getFilterBy().getMapOfFilters().get("eventno")!=null) {
where.and(qEpisode.eventno.containsIgnoreCase(pagination.getFilterBy().getMapOfFilters().get("eventno")));
}
if (pagination.getFilterBy().getMapOfFilters().get("address")!=null) {
where.and(qEpisode.address.formattedAddress.containsIgnoreCase(pagination.getFilterBy().getMapOfFilters().get("address")));
}
where.and(qEpisode.creatingUser.eq(user));
List<Episode> e = episodeRepository.findAll(where);
How would I now add a 3rd predicate for case name where case name is constructed of the first two people returned in the collection of people against a episode?
UPDATE
For clarification the DTO thats backs the UI view contains the "casename" attribute. It is created in the service layer when Domain objects are converted to DTO:
episodeDashboard.setNames(episodePersonList.get(0).getPerson().getSurname().toUpperCase() +" & " +episodePersonList.get(1).getPerson().getSurname().toUpperCase());
Not easily unless you delegate some of the processing to the database.
If we can get the case_name property to be populated at the database tier rather than as a derived property in the application logic then the front-end code becomes trivial.
We can do this by means of a view. The exact definition of this will depend on your database however the output would be something like this:
episode_summary_vw
+------------+-------------------------+
| epsiode_id | case_name |
+------------+-------------------------+
| 5 | Eastwood & Joilee|
| 6 | Pitt & Aniston|
| 7 | Aniston & Pitt|
+------------+-------------------------+
For Oracle it looks like LISTAGG function is what you would want and for MySQL the GROUP_CONCAT functions. In MySQL then I think this would look something like:
CREATE VIEW episode_summary_vw as
SELECT ep.episode_id, GROUP_CONCAT(p.surname SEPARATOR ' & ')
FROM episode_person ep
INNER JOIN person p on p.id = ep.person_id
GROUP BY ep.episode_id;
-- todo: needs limit to first 2 records
Once we have a view then we can simply map the case_name to the Episode entity using the #SecondaryTable functionality of JPA:
#Entity
#Table(name = "episodes")
#SecondaryTable(name = "episode_summary_vw", primaryKeyJoinColumna = #PrimaryKeyJoinColumn(name="episode_id", reference_column_name="id"))
public class Episode {
#Column(name ="case_name", table = "episode_summary_vw")
private String caseName;
}
You then filter and sort on the property as for any other field:
if (pagination.getFilterBy().getMapOfFilters().get("caseName")!=null) {
where.and(qEpisode.caseName.containsIgnoreCase(pagination.getFilterBy().
getMapOfFilters().get("caseName")));
}
I've got a MySQL database schema with 3 tables as follows:
mysql> describe results;
+--------------+------------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+--------------+------------------+------+-----+---------+----------------+
| id | int(10) unsigned | NO | PRI | NULL | auto_increment |
| run_at | datetime | YES | | NULL | |
| trials | int(10) unsigned | YES | | NULL | |
+--------------+------------------+------+-----+---------+----------------+
mysql> describe result_details;
+------------------------+------------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+------------------------+------------------+------+-----+---------+----------------+
| id | int(10) unsigned | NO | PRI | NULL | auto_increment |
| results_id | int(10) | NO | | NULL | |
| summarys_id | int(10) | YES | | NULL | |
+------------------------+------------------+------+-----+---------+----------------+
mysql> describe summarys;
+-------+------------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------+------------------+------+-----+---------+----------------+
| mean | double | YES | | NULL | |
| id | int(10) unsigned | NO | PRI | NULL | auto_increment |
+-------+------------------+------+-----+---------+----------------+
Where a Result object can have several ResultDetail members. However, semantically, it makes sense to have one of these details stand out among the rest as a 'overall' detail. Therefore, I have the following classes:
Result.java (some members and methods removed for brevity)
#Entity
#Table(name="results")
public class Result extends BaseEntity {
#Column(name="run_at")
#Temporal(TemporalType.TIMESTAMP)
private Date runAt;
#Column(name="trials")
private Integer trials;
#OneToOne(mappedBy="result", cascade = {CascadeType.ALL})
private ResultDetails overallStats;
#OneToMany(mappedBy="result", cascade = {CascadeType.ALL})
private List<ResultDetails> resultDetails = new ArrayList<ResultDetails>();
}
ResultDetail.java
#Entity
#Table(name="result_details")
public class ResultDetails extends BaseEntity {
#ManyToOne
#JoinColumn(name = "results_id", nullable=false)
#NotNull
private Result result;
#OneToOne(cascade=CascadeType.ALL)
#JoinColumn(name="summarys_id", nullable=true)
private Summary summary;
}
When I create persistent entities from my main as follows:
public static void main (String [] args) {
Result result = new Result();
ResultDetails detail1 = new ResultDetails();
ResultDetails detail2 = new ResultDetails();
Summary s1 = new Summary();
Summary s2 = new Summary();
result.setRunAt(new Date());
result.setTrials(1000000);
detail1.setResult(result);
s1.setMean(3.0);
detail1.setSummary(s1);
result.setOverallStats(detail1);
detail2.setCybervarResult(result);
s2.setMean(11.0);
detail2.setSummary(s2);
result.addDetails(detail2);
Session session = HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
session.saveOrUpdate(result);
session.getTransaction().commit();
HibernateUtil.shutdown();
}
It adds the appropriate rows to the tables. However, when I retrieve the data as demonstrated by the following additional main file:
Session session = HibernateUtil.getSessionFactory().openSession();
Result result = session.get(CybervarResult.class, 6);
result.getOverallStats().getSummary();
result.getResultDetails().size();
HibernateUtil.shutdown();
System.out.println(result.getOverallStats().getSummary().getMean());
System.out.println(result.getResultDetails().get(0).getSummary().getMean());
Hibernate is able to correctly populate the 'overallStats' and 'resultDetails' objects. How is it able to differentiate the two rows in the result_details table? As far as I can tell, there is nothing to distinguish the two from each other. Does Hibernate implement hidden tables/rows to manage which member variables correspond to which rows? If I were to create this database from mysql queries instead of through the hibernate API, how would Hibernate know which row should be the 'overallStats' and which rows should belong to the 'resultDetails' collection?
For reference, the rows created look as follows:
mysql> select * from results;
+----+---------------------+---------+
| id | run_at | trials |
+----+---------------------+---------+
| 6 | 2017-11-13 09:27:52 | 1000000 |
+----+---------------------+---------+
mysql> select * from result_details;
+----+------------+-------------+
| id | results_id | summarys_id |
+----+------------+-------------+
| 10 | 6 | 14 |
| 11 | 6 | 15 |
+----+------------+-------------+
hibernate.cfg.xml
<property name="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</property>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/usersdb</property>
<property name="hibernate.connection.username">test</property>
<property name="hibernate.connection.password">test</property>
<property name="hibernate.show_sql">true</property>
<property name="hibernate.format_sql">true</property>
<property name="hibernate.hbm2ddl.auto">validate</property>
I am getting the following error from my Hibernate code:
com.mysql.jdbc.exceptions.MySQLSyntaxErrorException: Unknown column 'bulletin0_.bulletin_date' in 'field list'
There is no such bulletin_date column in my table, nor is there such a name in my model class. It's just called date. Here is the line where I'm getting the error.
Query query = session.createQuery("from Bulletin where approved = true");
Here is my model class (I'm leaving out the getters and setters):
public class Bulletin {
#Id
#Column(name="id")
#GeneratedValue
private int id;
#Column(name="date")
private String date;
#Column(name="name")
private String name;
#Column(name="subject")
private String subject;
#Column(name="note")
private String note;
#Column(name="approved")
private boolean approved;
}
Here is my table definition.
+----------+---------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+----------+---------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| date | varchar(10) | YES | | NULL | |
| name | varchar(30) | YES | | NULL | |
| subject | varchar(50) | YES | | NULL | |
| note | varchar(2500) | YES | | NULL | |
| approved | tinyint(1) | YES | | NULL | |
+----------+---------------+------+-----+---------+----------------+
I had the wrong column names in my Bulletin.hbm.xml file. When I corrected it, the problem was solved.
I'm having problems with a Hibernate criteria. I'm trying to make a Criteria where I look at the id of a member object of the class the query returns.
For example:
Criteria crit = session.createCriteria(Enquiry.class);
crit.add(Expression.eq("lecture.admin.id", userId));`
The result of this is an exception:
org.hibernate.QueryException: could not resolve property: lecture.admin.id of: xxx.yyy.Enquiry
The Enquiry class does contain the lecture variable, which in turn contains the admin variable. I have tried using lecture.id and that works fine.
Is there a limit to the number of levels you can go down the object hierarchy like this?
Thanks!
Code snippets:
public class Lecture extends TransferItem {
private User admin;
public User getAdmin() {
return admin;
}
}
The 'User' class extends the Person class, which in turn extends an Itemclass, which has the getId()method:
public Integer getId() {
if (id != null) {
return id;
}
return TransferBean.NOT_SET;
}
From the Hibernate mapping XML:
<class name="User" table="user">
<id column="user_id" name="id">
<generator class="increment"/>
</id>
...
<class name="Lecture" table="lecture">
<many-to-one class="User" column="user_fk" lazy="false" name="admin"/>`
This is the user table:
mysql> show columns from user;
+-----------------+--------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-----------------+--------------+------+-----+---------+-------+
| user_id | int(11) | NO | PRI | | |
| firstname | varchar(50) | YES | | NULL | |
| lastname | varchar(50) | YES | | NULL | |
| signature | varchar(16) | YES | | NULL | |
| email_signature | varchar(256) | YES | | NULL | |
| password | varchar(32) | YES | | NULL | |
| phone | varchar(16) | YES | | NULL | |
| email | varchar(255) | YES | UNI | NULL | |
| lecturer_fk | int(11) | YES | MUL | NULL | |
| access | int(11) | YES | | NULL | |
| deleted | tinyint(1) | YES | | NULL | |
+-----------------+--------------+------+-----+---------+-------+
11 rows in set (0.02 sec)`
You can't use nested paths directly in Criteria API (unlike HQL). Instead, you need to create nested criteria instances or define aliases on each "entity.property" pair starting with the first non-root entity:
Criteria criteria = session.createCriteria(Enquiry.class)
.createAlias("lecture", "l")
.createAlias("l.admin", "a")
.add( Restrictions.eqProperty("a.id", userId) );
Note that the very first property is not prefixed as it belongs to the root entity (Enquiry), the others are prefixed with previous level alias. Details are in the documentation.
Also note that id is a special property when it comes to associations; in your case user_fk is a column located in lecture table. It should, therefore, be possible (provided that the mappings you've posted are accurate) to rewrite the above criteria as:
Criteria criteria = session.createCriteria(Enquiry.class)
.createAlias("lecture", "l")
.add( Restrictions.eqProperty("l.admin.id", userId) );
thus eliminating extra join.
Criteria crit = session.createCriteria(Enquiry.class)
crit.createAlias("lecture.admin", "lectureAdmin");
crit.add(Expression.eq("lectureAdmin.id", userId));
You can indeed hit issues when you go down too deep in the object graph. I usually get around this by creating an alias as shown above.