Hibernate SQL Optimization Tips dynamic-insert= "true" dynamic-update= "true"

<java persistence with Hibernate>, who was reading the father of Hibernate recently, was quite fruitful.
In our familiar hibernate mapping file There is also a lot of space, many worthy of my attention.
The class tag of the hibernate mapping file uses Dynamic-insert,dynamic-update to optimize the generated SQL statements, improve the efficiency of SQL execution, and ultimately improve system performance.
For example, there is a user class.

4. Public class User {
8. /** Creates a new instance of User * /
10. public User () {
12. }
14. private long ID;
16. private int age ;
20. private String FirstName;
22. private String LastName;
24. private Set emailaddresses;
26. Omit getter and Setter methods
28. }

The Hibernate mapping file (User.hbm.xml, omitting the file header declaration) is defined as:

2. <hibernate-mapping>
4. <class name="model. User " table=" Users " >
6. <ID name="id" column="id">
8. <generator class="native"/>
10. </ID>
12. <property Name=' age '/>
14. <property Name="FirstName"/>
16. <property Name="LastName"/>
20. <set name="emailaddresses" table="Person_email_addr">
22. <key column="person_id"/>
24. <element Type="string" column="email_addr"/>
26. </Set>
28. </class>
30. </hibernate-mapping>

We write a test class to test Usertest.

2. Public class usertest extends TestCase {
6. public usertest (String testname) {
8. Super(testname);
10. }
14. private Session session;
16. private sessionfactory sessionfactory;
20. protected void setUp () throws Exception {
22. Sessionfactory=hibernateutil.getsessionfactory ();
24. Session=sessionfactory.opensession ();
26. Session.gettransaction (). Begin ();
28. }
32. protected void TearDown () throws Exception {
34. Session.gettransaction (). commit ();
36. Session.close ();
40. }
44. /**  
46. * Test of Getage method, of class model. User.   
48. */  
50. public void testsaveuser () {
52. System.out.println ("================testsaveuser=================");
56. User user = new user ();
58. User.setage ();
60. Session.save (user);
62. Assertnotnull ("ID is assigned!")   , User.getid ());
64. }
66. public void testupdateuser () {
68. System.out.println ("================testupdateuser=================");
72. User user = new user ();
74. User.setage ();
76. Session.save (user);
78. Assertnotnull ("ID is assigned!")   , User.getid ());
82. User _user= (user) Session.get (user).   Class, User.getid ());
84. _user.setfirstname ("Array");
86. Session.update (_user);
90. }
96. }

After the test is run, a complete SQL statement is generated (note that the Hibernate property Show_sql is set to true).

1. ================testsaveuser=================
2. Hibernate:insert into the Users (age, FirstName, LastName) VALUES (?,?,?)
3. ================testupdateuser=================
4. Hibernate:insert into the Users (age, FirstName, LastName) VALUES (?,?,?)
5. Hibernate:update Users set age=?, Firstname=?, Lastname=? where id=?

If we add dynamic-insert= "true" dynamic-update= "true" in <class ...>, it becomes as follows.

1. <class name="model. User " table=" Users " dynamic-insert=" true " dynamic-update= "true">

Run the test class again, and you will find that the fields involved in the generated SQL contain only the table field for the modified property in the user class.

1. ================testsaveuser=================
2. Hibernate:insert into Users values (?)
3. ================testupdateuser=================
4. Hibernate:insert into Users values (?)
5. Hibernate:update Users set firstname=? where id=?

If the structure of a table is complex and there are many fields, the use of dynamic-insert,dynamic-update can improve performance slightly.

-------------------------------------------

Hibernate mapping file, the class element can be defined in the  
dynamic-update= "True|false" &NBSP
dynamic-insert= "True|false"  

Dynamic-update (optional, false by default): Specifies that SQL for update will be dynamically generated at run time, and update only those fields that have changed.  

Dynamic-insert (optional, false by default): Specifies that SQL for insert is dynamically generated at run time and contains only those non-null value fields.  

Note that dynamic-update and Dynamic-insert settings are not inherited to subclasses, so the <subclass> or <joined-subclass> element may need to be set again.  

Performance issue: The SQL UPDATE statement is pre-generated, and if you add dynamic, you need to scan each property's changes each time you update, and then generate an update, which has a slightly more efficient effect.  
If you don't have a special requirement, it's a good default.  

If you update multiple records at one time, hibernate will not be able to use ExecuteBatch for batch updates, which is much less efficient. Also, in this case, multiple SQL means that the database has to do multiple SQL statement compilation.  

Whether or not to use:  
Specific problems specifically analyzed, if a table field is more, and often just update a record of one or two fields, then dynamic update will be more effective. and the generated SQL statements are easy to understand.  

Transferred from: http://blog.163.com/ma_yaling/blog/static/245367201051854849268/

Related:

Hibernate Update updates only modified fields

Hibernate SQL Optimization Tips dynamic-insert= "true" dynamic-update= "true"