JDX Programming Code Snippets

Mapping One-To-Many Relationships


This snippet shows how to define collection classes and one-to-many relationships. It also shows example of deep and shallow operations involving related objects.

In the example class model, a company has many departments.

Class Definitions

                
                

                 
    
                   
  1. package com.softwaretree.jdxrelationshipsexample.model; 
    2. 
                   
  2.  
    3. 
                   
  3. public class SimpleDept { 
    4. 
                   
  4.  
    5. 
                   
  5.    private int deptId;  
    6. 
                   
  6.    private String companyId; 
    7. 
                   
  7.    private String deptName;  
    8. 
                   
  8.   
    9. 
                   
  9.    public SimpleDept() { 
    10. 
                   
  10.    } 
    11. 
                   
  11.     // Other constructors and accessor (setter/getter) methods omitted
    12. 

              

               

              
                
                

                 
    
                  
  1. package com.softwaretree.jdxrelationshipsexample.model;
    2. 
                  
  2.  
    3. 
                  
  3. import java.util.List;  
    4. 
                  
  4.  
    5. 
                  
  5. public class SimpleCompany {
    6. 
                  
  6.  
    7. 
                  
  7.     private String companyId;
    8. 
                  
  8.     private String companyName;
    9. 
                  
  9.     private String city;
    10. 
                  
  10.     private String state;
    11. 
                  
  11.     public List<SimpleDept> depts; // identified by companyId
    12. 
                  
  12.  
    13. 
                  
  13.     public SimpleCompany() {
    14. 
                  
  14.     }
    15. 
                  
  15.     // Other constructors and accessor (setter/getter) methods omitted
    16.
Notes:
  • A POJO (Plain Old Java Object) class with attributes of various types for a company.
    (line 5)
  • The depts attribute references a collection (ArrayList) of SimpleDept objects in a one-to-many relationship. We want this relationship to be of type BYVALUE, which means that, by default, the referenced collection of SimpleDept objects will be inserted, updated, or deleted with a referencing SimpleCompany object.
    (line 11)

Mapping Specification

              
              

              
    
                
  1. JDX_OBJECT_MODEL_PACKAGE com.softwaretree.jdxandroidrelationshipsexample.model
    2. 
                
  2.  
    3. 
                
  3. CLASS  .SimpleDept TABLE Simple_Dept
    4. 
                
  4.     PRIMARY_KEY deptId 
    5. 
                
  5. ;
    6. 
                
  6.  
    7. 
                
  7. COLLECTION_CLASS CollectionDept COLLECTION_TYPE JAVACOLLECTION ELEMENT_CLASS .SimpleDept 
    8. 
                
  8.     PRIMARY_KEY companyId
    9. 
                
  9.     ORDERBY_DESC deptId 
    10. 
                
  10. ;
    11. 
                
  11.  
    12. 
                
  12. CLASS .SimpleCompany TABLE Simple_Company
    13. 
                
  13.     PRIMARY_KEY companyId
    14. 
                
  14.     RELATIONSHIP depts REFERENCES CollectionDept BYVALUE WITH companyId 
    15. 
                
  15. ;
    16.
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 Object-Relational Mapping specification.
    (line 1)
  • Non-default table names have been specified for each class.
    (lines 3, 12)
  • The COLLECTION_CLASS specification for CollectionDept defines a collection of SimpleDept objects.
    (lines 7)
  • The SimpleDept objects belonging to a collection have the same value for the (PRIMARY_KEY) attribute companyId.
    (lines 8)
  • The collection of SimpleDept will be retrieved in the order of decreasing value of deptId (ORDERBY_DESC).
    (lines 9)
  • In the mapping specification for the SimpleCompany class, depts attribute references the previously defined CollectionDept by value (BYVALUE). This means that, by default, the referenced collection of SimpleDept objects will be inserted, updated, or deleted with the referencing SimpleCompany object.
    (lines 14)

Programming Example 

                
                

                
    
                    
  1. // Assuming JDXSetup of type JDXSetup is already initialized  
    2. 
                    
  2.  
    3. 
                    
  3. // Obtain ORM handles 
    4. 
                    
  4. JXResource jxResource = jdxSetup.checkoutJXResource();  
    5. 
                    
  5. JXSession jxSessionHandle = jxResource.getJXSessionHandle(); 
    6. 
                    
  6. JDXS jdxHandle = jxResource.getJDXHandle();
    7. 
                    
  7.  
    8. 
                    
  8. String companyClassName = SimpleCompany.class.getName();
    9. 
                    
  9. 
                    
  10. try {
                    
  11.     // Start a new transaction to make all the following statements  
    12. 
                    
  12.     // (until tx_commit) to execute as one unit of operation
    13. 
                    
  13.     jxSessionHandle.tx_begin();    
    14. 
                    
  14.   
    15. 
                    
  15.     // First delete existing SimpleCompany and associated SimpleDept objects 
    16. 
                    
  16.     jdxHandle.delete2(companyClassName, null, JDXS.FLAG_DEEP);  
    17. 
                    
  17.   
    18. 
                    
  18.     // Now create a new SimpleCompany object and the associated SimpleDept objects 
    19. 
                    
  19.     String companyId = "C1";    
    20. 
                    
  20.     company1 = new SimpleCompany(companyId, "Corporation 1", …); 
    21. 
                    
  21.   
    22. 
                    
  22.     List<SimpleDept> depts = new ArrayList<SimpleDept>(); 
    23. 
                    
  23.     dept1 = new SimpleDept(deptId1, companyId, "Department 1");
    24. 
                    
  24.     depts.add(dept1);  
    25. 
                    
  25.     dept2 = new SimpleDept(deptId2, companyId, "Department 2");
    26. 
                    
  26.     depts.add(dept2);  
    27. 
                    
  27.     company1.setDepts(depts); 
    28. 
                    
  28.   
    29. 
                    
  29.     // Now insert the newly created SimpleCompany along with the 
    30. 
                    
  30.     // associated SimpleDept objects with one JDX call 
    31. 
                    
  31.     jdxHandle.insert(company1, JDXS.FLAG_DEEP, null); 
    32. 
                    
  32.      
    33. 
                    
  33.     // Commit the transaction 
    34. 
                    
  34.     jxSessionHandle.tx_commit();
    35. 
                    
  35.      
    36. 
                    
  36.     // Retrieve all SimpleCompany objects along with their departments 
    37. 
                    
  37.     // with a deep query  
    38. 
                    
  38.     List queryResults = jdxHandle.query(companyClassName, null, JDXS.ALL,
                        JDXS.FLAG_DEEP, null);
    39. 
                    
  39.     
    40. 
                    
  40.     // Retrieve all SimpleCompany (top-level) objects without their departments 
    41. 
                    
  41.     // with a shallow query  
    42. 
                    
  42.     List queryResults = jdxHandle.query(companyClassName, null, JDXS.ALL,
                        JDXS.FLAG_SHALLOW, null);
    43. 
                    
  43. } catch (Exception ex) {
    44. 
                    
  44.     throw ex;
    45. 
                    
  45. } finally { 
    46. 
                    
  46.     jdxSetup.checkinJXResource(jxResource);
    47. 
                    
  47. }
    48.
Notes:
  • All the notes of the Simple Mapping 1 and Mapping One-To-One Relationships Programming Examples apply.
  • Whereas the Simple Mapping Example 1 uses a higher-level façade (JDXHelper) to interact with the JDX ORM system, this code snippet uses JXResource, JXSession, and JDXS objects to
    (lines 4, 5, 6, 13)
    • invoke multiple operations in one transaction and
    • to interact more directly with the ORM system.
  • 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.
    (lines 16, 31, 38, 42)
Previous
Next