Examples of org.jpox.store.rdbms.query.DiscriminatorIteratorStatement

org.jpox.store.rdbms.query.DiscriminatorIteratorStatement
Class to generate a QueryStatement that can be used for iterating through instances in a single table using a discriminator to distinguish between the classes. There are two modes of operation supported :-
Generated statement - candidate type
Let's assume that we have class A which is the candidate and this has subclasses A1, A2 that are stored in the same table (with different values of the discriminator). We want to find all objects of the candidate type and optionally its subclasses and we want information about what type the object is (A or A1 or A2). The query will be of the form
```
 SELECT [THIS.DISCRIMINATOR]  FROM A THIS [WHERE (THIS.DISCRIMINATOR = value1 || THIS.DISCRIMINATOR = value2 || THIS_DISCRIMINATOR = value3)] 
```
The SELECT of the discriminator column is optional. The WHERE clause is added where we don't want to include all possible classes that are stored in that table. You can omit the WHERE clause by specifying restrictDiscriminator as false.
Generated statement - candidate type with select table
Let's assume that we have a 1-N relation with a join table, and we want to find all elements of the candidate type (B) and optionally its subclasses (B1, B2). We need to select the join table, yet have a different candidate type. The query will be of the form
```
 SELECT [`ELEMENT`.DISCRIMINATOR] FROM SELECTTABLE THIS INNER JOIN B `ELEMENT` ON `ELEMENT`.B_ID = THIS.B_ID_EID  [WHERE (`ELEMENT`.DISCRIMINATOR = value1 OR `ELEMENT`.DISCRIMINATOR = value2 || `ELEMENT`.DISCRIMINATOR = value3)] 
```
The SELECT of the discriminator column is optional. The WHERE clause is added where we don't want to include all possible classes that are stored in that table. You can omit the WHERE clause by specifying restrictDiscriminator as false.
Selecting columns
It should be noted that the "SELECT" columns are not added here (with the exception of THIS.DISCRIMINATOR, which is an optional addition). They are added after creating this statement. This statement simply creates the basic form of the select statement. @version $Revision: 1.1 $

        {
            throw new JPOXException("Class "+objectClass.getName()+" is abstract, and a non abstract was expected.").setFatal();
        }


        // Form the query to find which one of these classes has the instance with this id
        DiscriminatorIteratorStatement discrimStmt = new DiscriminatorIteratorStatement(clr, new Class[] {primaryClass}, true, storeMgr, true);


        // Check all instances of this table to see if we have all possible candidates in our "options" list
        DatastoreClass primaryTable = storeMgr.getDatastoreClass(primaryClass.getName(), clr);
        StoreData[] storeData = storeMgr.getStoreDataForDatastoreContainerObject(primaryTable.getIdentifier());
        boolean haveAllCandidates = true;
        for (int i=0;i<storeData.length;i++)
        {
            if (storeData[i] instanceof MappedStoreData)
            {
                ClassTable tbl = (ClassTable)((MappedStoreData)storeData[i]).getDatastoreContainerObject();
                String[] managedClasses = tbl.getManagedClasses();
                for (int j=0;j<managedClasses.length;j++)
                {
                    boolean managedClassFound = false;
                    Iterator optionsIter = schemaDataOptions.iterator();
                    while (optionsIter.hasNext())
                    {
                        StoreData optionData = (StoreData)optionsIter.next();
                        if (optionData.getName().equals(managedClasses[j]))
                        {
                            managedClassFound = true;
                            break;
                        }
                    }
                    if (!managedClassFound)
                    {
                        haveAllCandidates = false;
                        break;
                    }
                }
                if (!haveAllCandidates)
                {
                    break;
                }
            }
        }


        if (haveAllCandidates)
        {
            // We have all possible candidates that are stored in this table so we can omit the restriction on the discriminator
            discrimStmt.setRestrictDiscriminator(false); // Just retrieve the discriminator for this id (accept any possible disc values)
        }


        // Create the statement
        QueryExpression stmt = discrimStmt.getQueryStatement(null);


        // WHERE (object id) = ?
        // We have to create a StateManager here just to map fields from the AppId key object to the table fields.
        // Really the table should have some way of doing this. TODO : Refactor this
        StateManager sm = StateManagerFactory.newStateManagerForHollow(om, objectClass, id);

View Full Code Here

                }
                else
                {
                    candidates = new Class[] {candidateClass};
                }
                query = (new DiscriminatorIteratorStatement(clr, 
                    candidates, subclasses, storeMgr, true)).getQueryStatement(candidateAlias);
            }
            else
            {
                // Use a UNION since we need to join across multiple tables

View Full Code Here

                Class[] cls = new Class[clsNames.length];
                for( int i=0; i<clsNames.length; i++)
                {
                    cls[i] = clr.classForName(clsNames[i]);
                }
                stmt = new DiscriminatorIteratorStatement(clr,
                    cls, true, this.storeMgr, true).getQueryStatement(null);
            }
            else
            {
                stmt = new DiscriminatorIteratorStatement(clr, new Class[] {clr.classForName(elementInfo[0].getClassName())},
                    true, this.storeMgr, true).getQueryStatement(null);
            }
            iterateUsingDiscriminator = true;
        }
        else

View Full Code Here

                Class[] cls = new Class[clsNames.length];
                for( int i=0; i<clsNames.length; i++)
                {
                    cls[i] = clr.classForName(clsNames[i]);
                }
                stmt = new DiscriminatorIteratorStatement(clr,
                    cls, true, this.storeMgr, true).getQueryStatement(null);
            }
            else
            {
                stmt = new DiscriminatorIteratorStatement(clr, new Class[] {clr.classForName(elementInfo[0].getClassName())},
                    true, this.storeMgr, true).getQueryStatement(null);
            }
            iterateUsingDiscriminator = true;
        }
        else

View Full Code Here

                        Class[] cls = new Class[clsNames.length];
                        for (int j=0; j<clsNames.length; j++)
                        {
                            cls[j] = clr.classForName(clsNames[j]);
                        }
                        elementStmt = new DiscriminatorIteratorStatement(clr, cls, 
                            true, this.storeMgr, true, allowsNull,
                            containerTable, elementMapping, elmIdentifier).getQueryStatement(null);
                    }
                    else
                    {
                        elementStmt = new DiscriminatorIteratorStatement(clr, new Class[] {elementCls}, 
                            true, this.storeMgr, true, allowsNull,
                            containerTable, elementMapping, elmIdentifier).getQueryStatement(null);
                    }
                    iterateUsingDiscriminator = true;
                }

View Full Code Here

                        Class[] cls = new Class[clsNames.length];
                        for( int j=0; j<clsNames.length; j++)
                        {
                            cls[j] = clr.classForName(clsNames[j]);
                        }
                        elementStmt = new DiscriminatorIteratorStatement(clr, cls,
                            true, this.storeMgr, true, allowsNull,
                            containerTable, elementMapping, elmIdentifier).getQueryStatement(null);
                    }
                    else
                    {
                        elementStmt = new DiscriminatorIteratorStatement(clr, new Class[] {elementCls}, 
                            true, this.storeMgr, true, allowsNull,
                            containerTable, elementMapping, elmIdentifier).getQueryStatement(null);
                    }
                    iterateUsingDiscriminator = true;
                }

View Full Code Here

                Class[] cls = new Class[clsNames.length];
                for (int j=0; j<clsNames.length; j++)
                {
                    cls[j] = clr.classForName(clsNames[j]);
                }
                stmt = new DiscriminatorIteratorStatement(clr, 
                    cls, true, this.storeMgr, true).getQueryStatement(null);
            }
            else
            {
                stmt = new DiscriminatorIteratorStatement(clr, new Class[] {elementCls},
                    true, this.storeMgr, true).getQueryStatement(null);
            }
            iterateUsingDiscriminator = true;


            // Add inner join to the container table

View Full Code Here

                Class[] cls = new Class[clsNames.length];
                for( int i=0; i<clsNames.length; i++)
                {
                    cls[i] = clr.classForName(clsNames[i]);
                }
                stmt = new DiscriminatorIteratorStatement(clr,
                    cls, true, this.storeMgr, true).getQueryStatement(null);
            }
            else
            {
                stmt = new DiscriminatorIteratorStatement(clr, new Class[] {valueCls},
                    true, this.storeMgr, true).getQueryStatement(null);
            }
            iterateUsingDiscriminator = true;
        }
        else

View Full Code Here

                Class[] cls = new Class[clsNames.length];
                for (int j=0; j<clsNames.length; j++)
                {
                    cls[j] = clr.classForName(clsNames[j]);
                }
                stmt = new DiscriminatorIteratorStatement(clr,
                    cls, true, this.storeMgr, true).getQueryStatement(null);
            }
            else
            {
                stmt = new DiscriminatorIteratorStatement(clr, new Class[] {elementCls},
                    true, this.storeMgr, true).getQueryStatement(null);
            }


            iterateUsingDiscriminator = true;

View Full Code Here

                        Class[] cls = new Class[clsNames.length];
                        for( int j=0; j<clsNames.length; j++)
                        {
                            cls[j] = clr.classForName(clsNames[j]);
                        }
                        elementStmt = new DiscriminatorIteratorStatement(clr, cls,
                            true, this.storeMgr, true, allowsNull,
                            containerTable, elementMapping, elmIdentifier).getQueryStatement(null);
                    }
                    else
                    {
                        elementStmt = new DiscriminatorIteratorStatement(clr, new Class[] {elementCls}, 
                            true, this.storeMgr, true, allowsNull,
                            containerTable, elementMapping, elmIdentifier).getQueryStatement(null);
                    }
                    iterateUsingDiscriminator = true;
                }

View Full Code Here

TOP

Related Classes of org.jpox.store.rdbms.query.DiscriminatorIteratorStatement

org.jpox.metadata.AbstractClassMetaData

org.jpox.metadata.DiscriminatorMetaData

org.jpox.store.mapped.expression.LogicSetExpression

org.jpox.store.mapped.expression.NullLiteral

org.jpox.store.mapped.expression.QueryExpression

org.jpox.store.mapped.expression.ScalarExpression

org.jpox.store.mapped.mapping.JavaTypeMapping

org.jpox.store.rdbms.extent.ClassTableExtent

org.jpox.store.rdbms.RDBMSStoreHelper

org.jpox.store.rdbms.scostore.FKListStore

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.

Examples of org.jpox.store.rdbms.query.DiscriminatorIteratorStatement

Generated statement - candidate type

Generated statement - candidate type with select table

Selecting columns

Related Classes of org.jpox.store.rdbms.query.DiscriminatorIteratorStatement