JDX Programming Code Snippets

Mapping Many-To-Many Relationships


This snippet shows how to define collection classes, join classes, and many-to-many relationships. An intermediate join class is used to hold the references for a many-to-many relationship. The snippet also shows examples of deep and shallow operations involving related objects. For a many-to-many relationship, the entities involved in the relationship are considered independent in the sense that insert, update, and delete operations don't go beyond the intermediate join class (table).

In the example object model, one user may have many groups and one group may have many users.

Class Definitions

                
                

                 
    
                    
  1. package com.softwaretree.jdxrelationshipsexample.model;
    2. 
                    
  2.  
    3. 
                    
  3. import java.util.List;
    4. 
                    
  4.  
    5. 
                    
  5. public class Group {  
    6. 
                    
  6.   public int gId; 
    7. 
                    
  7.   public String gName;  
    8. 
                    
  8.   public List<User> users; // A collection of User objects
    9. 
                    
  9.  
    10. 
                    
  10.   public Group() {
    11. 
                    
  11.   }
    12. 
                    
  12.   // Other constructors and accessor (setter/getter) methods omitted 
    13.
Notes:
  • A POJO (Plain Old Java Object) class with attributes of various types for a group.
    (line 5)
  • The users attribute references a collection (e.g., List) of User objects in a many-to-many relationship. We want this relationship to be of type BYVALUE, which means that, by default, the referenced collection of UserGroup objects, described later, will be inserted, updated, or deleted with a referencing Group object.
    (line 8)
                
                

                  
    
                    
  1. package com.softwaretree.jdxrelationshipsexample.model;
    2. 
                    
  2.  
    3. 
                    
  3. import java.util.Vector;  
    4. 
                    
  4.  
    5. 
                    
  5. public class User {  
    6. 
                    
  6.   public int uId; 
    7. 
                    
  7.   public String uName; 
    8. 
                    
  8.   public Vector<Group> groups; // A Collection of Group objects 
    9. 
                    
  9.  
    10. 
                    
  10.   public User() {  
    11. 
                    
  11.   }  
    12. 
                    
  12.   // Other constructors and accessor (setter/getter) methods omitted
    13.
Notes:
  • A POJO (Plain Old Java Object) class with attributes of various types for a group.
    (line 5)
  • The groups attribute references a collection (e.g., Vector) of Group objects in a many-to-many relationship. We want this relationship to be of type BYVALUE, which means that, by default, the referenced collection of UserGroup objects, described later, will be inserted, updated, or deleted with a referencing User object.
    (line 8)
                
                

                 
    
                    
  1. package com.softwaretree.jdxrelationshipsexample.model; 
    2. 
                    
  2.  
    3. 
                    
  3. public class UserGroup {  
    4. 
                    
  4.    public int uId; 
    5. 
                    
  5.    public int gId; 
    6. 
                    
  6.  
    7. 
                    
  7.    public UserGroup() { 
    8. 
                    
  8.    }  
    9. 
                    
  9.  
    10. 
                    
  10.    // Other constructors and accessor (setter/getter) methods omitted 
    11.
Notes:
  • A join class consisting of primary key attributes of the two classes (User and Group) involved in a many-to-many relationship.
    • This class is mainly used to define the mapping specification.
    • JDX automatically creates and manages instances of this join class.
    • Conceptually, the collection of UserGroup objects with the same value of the uId attribute corresponds to the related collection of Group objects for the User object with the given uId value. Similarly, the collection of UserGroup objects with the same value of the gId attribute corresponds to the related collection of User objects for the Group object with the given gId value.
      (line 3)

Mapping Specification

           
           

           
    
            
  1. JDX_OBJECT_MODEL_PACKAGE com.softwaretree.jdxandroidrelationshipsexample.model
    2. 
            
  2.  
    3. 
            
  3. CLASS .UserGroup TABLE USER_GRP 
    4. 
            
  4.   PRIMARY_KEY uId gId 
    5. 
            
  5. ;
    6. 
            
  6.  
    7. 
            
  7. JOIN_COLLECTION_CLASS ListUsers COLLECTION_TYPE JAVACOLLECTION
ELEMENT_CLASS .User JOIN_CLASS .UserGroup  
    8. 
            
  8.   PRIMARY_KEY gId
    9. 
            
  9.   JOIN_KEY uId
    10. 
            
  10.   ORDERBY uName 
    11. 
            
  11. ;
    12. 
            
  12.  
    13. 
            
  13. CLASS .Group TABLE GRP  
    14. 
            
  14.   PRIMARY_KEY gId 
    15. 
            
  15.   RELATIONSHIP users REFERENCES ListUsers BYVALUE WITH gId  
    16. 
            
  16. ; 
    17. 
            
  17.  
    18. 
            
  18. JOIN_COLLECTION_CLASS VectorGroups COLLECTION_TYPE VECTOR
ELEMENT_CLASS .Group JOIN_CLASS .UserGroup 
    19. 
            
  19.   PRIMARY_KEY uId 
    20. 
            
  20.   JOIN_KEY gId   
    21. 
            
  21. ; 
    22. 
            
  22.  
    23. 
            
  23. CLASS .User TABLE USER
    24. 
            
  24.   PRIMARY_KEY uId 
    25. 
            
  25.   RELATIONSHIP groups REFERENCES VectorGroups BYVALUE WITH uId
    26. 
            
  26. ;
    27.
Notes:
  • JDX_OBJECT_MODEL_PACKAGE specifies the default package name for all the classes whose names are specified starting with a dot (.). This is to facilitate abbreviating the class names in the mapping specification.
    (line 1)
  • This defines the mapping for the join class UserGroup that holds references for the many-to-many relationship between the User and Group classes.
    (line 3)
  • The PRIMARY_KEY of the join class is defined by the combination of primary or reference key attributes of the classes involved in the relationship.
    (line 4)
  • The JOIN_COLLECTION_CLASS specification for ListUsers defines a collection of User objects using intermediate joining objects of the UserGroup class.
    (line 7)
  • The User objects belonging to a collection for a given Group object have the same value for the attribute gId (PRIMARY_KEY) in the joining UserGroup objects.
    (line 8)
  • The JOIN_KEY defines the names (uId) of those attributes of the join class (UserGroup) whose values match the values of the corresponding attributes of all the User objects on the many-side of the relationship.
    (line 9)
  • The collection of Users will be retrieved in the order by value of uName (ORDERBY).
    (line 10)
  • The users attribute of the Group class references the previously defined ListUsers object by value (BYVALUE). This means that, by default, the referenced collection of UserGroup join objects will be inserted, updated, or deleted with the referencing Group object.
    (line 15)
  • The JOIN_COLLECTION_CLASS specification for VectorGroups defines a collection (Vector) of Group objects using intermediate joining objects of the UserGroup class.
    (line 18)
  • The Group objects belonging to a collection for a given User object have the same value for the attribute uId (PRIMARY_KEY) in the joining UserGroup objects.
    (line 19)
  • The JOIN_KEY defines the names (gId) of those attributes of the join class (UserGroup) whose values match the values of the corresponding attributes of all the Group objects on the many-side of the relationship.
    (line 20)
  • The groups attribute of the User class references the previously defined VectorGroups object by value (BYVALUE). This means that, by default, the referenced collection of UserGroup join objects will be inserted, updated, or deleted with the referencing User object.
    (line 25)

Programming Example 

                
                

                
    
                    
  1. // Obtain ORM handles.
    2. 
                    
  2. JXResource jxResource = jdxSetup.checkoutJXResource(); 
    3. 
                    
  3. JXSession jxSessionHandle = jxResource.getJXSessionHandle();
    4. 
                    
  4. JDXS jdxHandle = jxResource.getJDXHandle();  
    5. 
                    
  5.   
    6. 
                    
  6. String userClassName = User.class.getName(); 
    7. 
                    
  7. String groupClassName = Group.class.getName(); 
    8. 
                    
  8.   
    9. 
                    
  9. int gId = 1;  
    10. 
                    
  10. int uId = 101; 
    11. 
                    
  11. 
                    
  12. String gNameBase = "group";  
    13. 
                    
  13. String uNameBase = "user"; 
    14. 
                    
  14. 
                    
  15. // Many-to-many relationship among two classes employs an intermediate join class (table).
    16. 
                    
  16. //
    17. 
                    
  17. // If an insert, update, and delete operation on the instances of such classes is done 
    18. 
                    
  18. // in a 'deep' fashion, the operation is limited to the top-level objects and the
    19. 
                    
  19. // associated join class objects.  In other words, these operations do not change 
    20. 
                    
  20. // the related objects in the database to avoid unintended recursion.
    21. 
                    
  21. // 
    22. 
                    
  22. // A 'deep' query operation does extend upto the related objects but avoids recursion by 
    23. 
                    
  23. // not fetching the related top-level original objects.
    24. 
                    
  24.       
    25. 
                    
  25. try { 
    26. 
                    
  26.     // ********** Start a transaction to delete all the existing objects.  *********** 
    27. 
                    
  27.     jxSessionHandle.tx_begin(); 
    28. 
                    
  28.      
    29. 
                    
  29.     // First delete all the existing User objects from the database.
    30. 
                    
  30.     // This should also get rid of the associated join table entries 
    31. 
                    
  31.     // because of the use of the parameter JDXS.FLAG_DEEP. 
    32. 
                    
  32.     jdxHandle.delete2(userClassName, null, JDXS.FLAG_DEEP); 
    33. 
                    
  33. 
                    
  34.     // Now delete all the existing Group objects from the database. 
    35. 
                    
  35.     // There is no need of getting rid of the associated join table entries because  
    36. 
                    
  36.     // they would have already been deleted while deleting User object earlier.
                    
  37.     // Hence the use of the parameter JDXS.FLAG_SHALLOW.
    38. 
                    
  38.     jdxHandle.delete2(groupClassName, null, JDXS.FLAG_SHALLOW); 
    39. 
                    
  39.  
    40. 
                    
  40.     // Commit the transaction.
    41. 
                    
  41.     jxSessionHandle.tx_commit();
    42. 
                    
  42.  
    43. 
                    
  43.     // ********** Now create a new Group with 2 new User objects.
    44. 
                    
  44.     Group g1 = new Group(gId, gNameBase+gId); 
    45. 
                    
  45. 
                    
  46.     User u1  = new User(uId, uNameBase+uId); 
    47. 
                    
  47.     uId++; 
    48. 
                    
  48.     User u2  = new User(uId, uNameBase+uId); 
    49. 
                    
  49.   
    50. 
                    
  50.     List <User> users = new ArrayList <User>();
    51. 
                    
  51.     users.add(u1);
    52. 
                    
  52.     users.add(u2);
    53. 
                    
  53.     g1.setUsers(users);  
    54. 
                    
  54.    
    55. 
                    
  55.     // ********** Now insert the new Group and its Users under a transaction ********* 
    56. 
                    
  56.     jxSessionHandle.tx_begin();  
    57. 
                    
  57. 
                    
  58.     // Users have to be inserted separately because a many_to_many insert does 
    59. 
                    
  59.     // not go beyond the join table. Users can be inserted after the join table is 
    60. 
                    
  60.     // populated if there is no referential integrity specified  
    61. 
                    
  61.     // at the database level.  Otherwise, user instances have to be inserted first.
    62. 
                    
  62.     jdxHandle.insertMany(users, JDXS.FLAG_SHALLOW, null);
    63. 
                    
  63. 
                    
  64.     // Insert the Group object now.  This would also populate the join table  
    65. 
                    
  65.     // for the associated User objects. 
    66. 
                    
  66.     jdxHandle.insert(g1, JDXS.FLAG_DEEP, null);
    67. 
                    
  67.       
    68. 
                    
  68.     // Commit the transaction. 
    69. 
                    
  69.     jxSessionHandle.tx_commit();
    70. 
                    
  70.       
    71. 
                    
  71.     // Now do a shallow query for all the Group objects  
    72. 
                    
  72.     List queryResults = jdxHandle.query(groupClassName, null, -1, JDXS.FLAG_SHALLOW, null);
    73. 
                    
  73.       
    74. 
                    
  74.     // Now do a deep query for all the Group objects along with the associated User objects  
    75. 
                    
  75.     queryResults  = jdxHandle.query(groupClassName, null, -1, JDXS.FLAG_DEEP, null);
    76. 
                    
  76. 
                    
  77.     // Now do a shallow query for all the User objects
    78. 
                    
  78.     queryResults = jdxHandle.query(userClassName, null, -1, JDXS.FLAG_SHALLOW, null); 
    79. 
                    
  79. 
                    
  80.     // Now do a deep query for all the User objects along with the associated Group objects  
    81. 
                    
  81.     queryResults  = jdxHandle.query(userClassName, null, -1, JDXS.FLAG_DEEP, null);
    82. 
                    
  82.       
    83. 
                    
  83.     // ********** Now create a new User u3 belonging to a new Group g2.
    84. 
                    
  84.     uId++;  
    85. 
                    
  85.     User u3 = new User(uId, uNameBase+uId); 
    86. 
                    
  86. 
                    
  87.     gId++;
    88. 
                    
  88.     Group g2 = new Group(gId, gNameBase+gId); 
    89. 
                    
  89.       
    90. 
                    
  90.     Vector<Group> groups = new Vector<Group>();
    91. 
                    
  91.     groups.addElement(g2); 
    92. 
                    
  92.     u3.setGroups(groups);
    93. 
                    
  93.  
    94. 
                    
  94.     // **********  Now insert the new User u3 and its Group under a transaction ********* 
    95. 
                    
  95.     jxSessionHandle.tx_begin();  
    96. 
                    
  96.       
    97. 
                    
  97.     // First insert the Group g2  
    98. 
                    
  98.     jdxHandle.insert(g2, JDXS.FLAG_SHALLOW, null); 
    99. 
                    
  99.      
    100. 
                    
  100.     // Now insert the User u3.  This would also populate the join table for 
    101. 
                    
  101.     // the associated Group object.
    102. 
                    
  102.     jdxHandle.insert(u3, JDXS.FLAG_DEEP, null);  
    103. 
                    
  103.       
    104. 
                    
  104.     // Make the new User u3 also associated with Group g1.
    105. 
                    
  105.     // The following is an alternate way of showing how existing objects can be connected 
    106. 
                    
  106.     // in many-to-many relationships by just populating the join object UserGroup. 
    107. 
                    
  107.     // We could have added Group g1 in the Vector groups above before inserting  
    108. 
                    
  108.     // User u3 to get the same effect.  
    109. 
                    
  109.     UserGroup ug = new UserGroup(u3.getuId(), g1.getgId()); 
    110. 
                    
  110.     jdxHandle.insert(ug, JDXS.FLAG_SHALLOW, null); 
    111. 
                    
  111.   
    112. 
                    
  112.     // Commit the transaction. 
    113. 
                    
  113.     jxSessionHandle.tx_commit(); 
    114. 
                    
  114.       
    115. 
                    
  115.     // At this point, we have the following situation:
    116. 
                    
  116.     //   Group g1 has User u1, u2, and u3. 
    117. 
                    
  117.     //   Group g2 has User u3
    118. .
                    
  118.     //   User u1 belongs to Group g1.
    119. 
                    
  119.     //   User u2 belongs to Group g1.
    120. 
                    
  120.     //   User u3 belongs to Group g1 and g2.
    121. 
                    
  121. 
                    
  122.     // Now do a deep query for all the User objects along with the associated Group objects 
    123. 
                    
  123.     queryResults  = jdxHandle.query(userClassName, null, -1, JDXS.FLAG_DEEP, null);
    124. 
                    
  124.   
    125. 
                    
  125.     // Now do a deep query for the Group g1 along with the associated User objects 
    126. 
                    
  126.     queryResults  = jdxHandle.query(groupClassName, "gId=" + g1.getgId(), -1,
                    JDXS.FLAG_DEEP, null); 
    127. 
                    
  127.  
    128. 
                    
  128.     // Now update the User object u3 in memory and then persist the changes in the database 
    129. 
                    
  129.     u3.setuName("new " + u3.getuName());  
    130. 
                    
  130.     jdxHandle.update(u3, JDXS.FLAG_SHALLOW, null);  
    131. 
                    
  131. 
                    
  132.     // Now do a deep query for the Group g2 along with the associated updated User u3 
    133. 
                    
  133.     queryResults  = jdxHandle.query(groupClassName, "gId=" + g2.getgId(), -1,
                    JDXS.FLAG_DEEP, null);
    134. 
                    
  134.     // Now do a deep delete of a Group g1.  This will also delete the join table 
    135. 
                    
  135.     // entries for Group g1 effectively removing all its relationships with any User
    136. 
                    
  136.     // objects.  The deep delete operation does not delete the related User objects though.
    137. 
                    
  137.     jdxHandle.delete(g1, JDXS.FLAG_DEEP, null);  
    138. 
                    
  138.       
    139. 
                    
  139.     // At this point, we have the following situation:  
    140. 
                    
  140.     //  Group g1 does not exist. 
    141. 
                    
  141.     //  Group g2 has User u3. 
    142. 
                    
  142.     //  User u1 belongs to none of the groups.  
    143. 
                    
  143.     //  User u2 belongs to none of the groups.  
    144. 
                    
  144.     //  User u3 belongs to Group g2.  
    145. 
                    
  145.       
    146. 
                    
  146.     // Do a deep query for all the User objects along with the associated Group objects  
    147. 
                    
  147.     queryResults  = jdxHandle.query(userClassName, null, -1, JDXS.FLAG_DEEP, null); 
    148. 
                    
  148.       
    149. 
                    
  149.     // Now do a deep query for the Group objects along with the associated User objects 
    150. 
                    
  150.     queryResults = jdxHandle.query(groupClassName, null, -1, JDXS.FLAG_DEEP, null); 
    151. 
                    
  151. 
                    
  152. } catch (Exception ex) {
    153. 
                    
  153.     throw ex;
    154. 
                    
  154. } finally {
    155. 
                    
  155.     jdxSetup.checkinJXResource(jxResource); 
    156. 
                    
  156. }
    157.
Notes:
  • All the notes of the Simple Mapping 1 and Mapping One-To-Many Relationships Programming Examples apply.
  • As various comments in the above programming code suggest, objects with relationships can easily be manipulated using JDX APIs in a shallow or deep fashion.
Previous
Next