Examples of org.jpox.store.mapped.DatastoreClass

org.jpox.store.mapped.DatastoreClass
Representation of a Java class in a datastore. In the case of RDBMS this will be a table (primary or secondary). In the case of a file-based structure this may be a directory. In the case of an XML-based structure this may be an element. @version $Revision: 1.37 $

     * @param im The macro to resolve.
     * @param clr The ClassLoaderResolver
     */
    public void resolveIdentifierMacro(MacroString.IdentifierMacro im, ClassLoaderResolver clr)
    {
        DatastoreClass ct = getDatastoreClass(im.className, clr);
        if (im.fieldName == null)
        {
            im.value = ct.getIdentifier().toString();
            return;
        }


        JavaTypeMapping m;
        if (im.fieldName.equals("this"))
        {
            if (!(ct instanceof ClassTable))
            {
                throw new JPOXUserException(LOCALISER_RDBMS.msg("050034", im.className));
            }


            if (im.subfieldName != null)
            {
                throw new JPOXUserException(LOCALISER_RDBMS.msg("050035", im.className, im.fieldName, im.subfieldName));
            }
            m = ((DatastoreContainerObject) ct).getIDMapping();
        }
        else
        {
            AbstractMemberMetaData fmd = getMetaDataManager().getMetaDataForMember(im.className, im.fieldName, clr);
            m = ct.getFieldMapping(fmd);
            DatastoreContainerObject t = getDatastoreContainerObject(fmd);
            if (im.subfieldName == null)
            {
                if (t != null)
                {

View Full Code Here

     * @return Element information relating to the element type
     */
    protected ElementInfo[] getElementInformationForClass()
    {
        ElementInfo[] info = null;
        DatastoreClass tbl;
        String[] clsNames;
        if (!clr.classForName(elementType).isInterface())
        {
            tbl = storeMgr.getDatastoreClass(elementType, clr);
            clsNames = new String[] {elementType};
        }
        else
        {
            clsNames = storeMgr.getOMFContext().getMetaDataManager().getClassesImplementingInterface(elementType, clr);
            tbl = storeMgr.getDatastoreClass(clsNames[0], clr);
        }
        if (tbl == null)
        {
            AbstractClassMetaData[] subclassCmds = storeMgr.getClassesManagingTableForClass(emd, clr);
            info = new ElementInfo[subclassCmds.length];
            for (int i=0;i<subclassCmds.length;i++)
            {
                DatastoreClass table = storeMgr.getDatastoreClass(subclassCmds[i].getFullClassName(), clr);
                info[i] = new ElementInfo(subclassCmds[i], table);
            }
        }
        else
        {
            info = new ElementInfo[clsNames.length];
            for (int i=0; i<clsNames.length; i++)
            {
                AbstractClassMetaData cmd = storeMgr.getOMFContext().getMetaDataManager().getMetaDataForClass(clsNames[i], clr);
                DatastoreClass table = storeMgr.getDatastoreClass(cmd.getFullClassName(), clr);
                info[i] = new ElementInfo(cmd, table);
            }
        }
        return info;
    }

View Full Code Here

    {
        if (!(mainTableExpr.getMainTable() instanceof DatastoreClass))
        {
            return null;
        }
        DatastoreClass mainTable = (DatastoreClass)mainTableExpr.getMainTable();
        if (mainTable.getDataStoreObjectIdMapping() == null)
        {
            return null;
        }


        return select(mainTableAlias, mainTable.getDataStoreObjectIdMapping(), alias);
    }

View Full Code Here

    {
        if (!(mainTableExpr.getMainTable() instanceof DatastoreClass))
        {
            return null;
        }
        DatastoreClass mainTable = (DatastoreClass)mainTableExpr.getMainTable();
        if (mainTable.getVersionMapping(false) == null)
        {
            return null;
        }


        return select(mainTableAlias, mainTable.getVersionMapping(false), alias);
    }

View Full Code Here

    {
        if (!(mainTableExpr.getMainTable() instanceof DatastoreClass))
        {
            return null;
        }
        DatastoreClass mainTable = (DatastoreClass)mainTableExpr.getMainTable();
        JavaTypeMapping fieldMapping = mainTable.getFieldMapping(fieldName);
        if (fieldMapping == null)
        {
            return null;
        }

View Full Code Here

     * @param candidateAlias Alias for the candidate
     * @return The new QueryStatement
     */
    public QueryExpression newQueryStatement(Class candidateClass, DatastoreIdentifier candidateAlias)
    {
        final DatastoreClass datastoreClass = storeMgr.getDatastoreClass(candidateClass.getName(), clr);
        final JavaTypeMapping m = datastoreClass.getIDMapping();
        final Class type = candidateClass;
        final boolean subclasses = this.subclasses;


        QueryExpression stmt = null;
        if (!queryUsingDiscriminator(datastoreClass) && !subclasses && hasAggregatedExpressionsOnly())

View Full Code Here


        ArrayList foreignKeys = new ArrayList();
        try
        {
            // FK from join table to owner table
            DatastoreClass referencedTable = storeMgr.getDatastoreClass(ownerType, clr);
            if (referencedTable != null)
            {
                // Single owner table, so add a single FK to the owner as appropriate
                ForeignKey fk = getForeignKeyToOwner(referencedTable, autoMode);
                if (fk != null)

View Full Code Here

        if (((RDBMSAdapter)storeMgr.getDatastoreAdapter()).supportsSchemasInTableDefinitions() && schemaName != null)
        {
            identifier.setSchemaName(schemaName);
        }


        DatastoreClass table = storeMgr.getDatastoreClass(identifier);
        if (table != null)
        {
            sequenceTable = (SequenceTable)table;
        }
        else

View Full Code Here

            }
        }
        else
        {
            // Apply ordering defined by <order-by>
            DatastoreClass elementTbl = elementInfo[0].getDatastoreClass();
            FieldOrder[] orderComponents = ownerMemberMetaData.getOrderMetaData().getFieldOrders();
            for (int i=0;i<orderComponents.length;i++)
            {
                String fieldName = orderComponents[i].getFieldName();
                JavaTypeMapping fieldMapping = elementTbl.getFieldMapping(elementInfo[0].getAbstractClassMetaData().getMetaDataForMember(fieldName));
                ScalarExpression exprIndex[] = new ScalarExpression[fieldMapping.getNumberOfDatastoreFields()];
                boolean descendingOrder[] = new boolean[fieldMapping.getNumberOfDatastoreFields()];
                for (int j=0;j<descendingOrder.length;j++)
                {
                    descendingOrder[j] = !orderComponents[i].isForward();

View Full Code Here

        boolean inserted = super.validateElementForWriting(sm, element, new FieldValues()
        {
            public void fetchFields(StateManager esm)
            {
                boolean isPersistentInterface = storeMgr.getOMFContext().getMetaDataManager().isPersistentInterface(elementType);
                DatastoreClass elementTable = null;
                if (isPersistentInterface)
                {
                    elementTable = storeMgr.getDatastoreClass(
                        storeMgr.getOMFContext().getMetaDataManager().getImplementationNameForPersistentInterface(elementType), clr);
                }
                else
                {
                    elementTable = storeMgr.getDatastoreClass(elementType, clr);
                }
                if (elementTable == null)
                {
                    // "subclass-table", persisted into table of other class
                    AbstractClassMetaData[] managingCmds = storeMgr.getClassesManagingTableForClass(emd, clr);
                    if (managingCmds != null && managingCmds.length == 1)
                    {
                        elementTable = storeMgr.getDatastoreClass(managingCmds[0].getFullClassName(), clr);
                    }
                    else
                    {
                        // Throw exception if managed by more than 1 other class
                        // TODO Localise this
                        throw new JPOXUserException("Field " + ownerMemberMetaData.getFullFieldName() + 
                            " is a List with element using subclass-table strategy BUT there are more than 1 subclass with table. This is not yet supported by JPOX");
                    }
                }
                if (elementTable != null)
                {
                    JavaTypeMapping externalFKMapping = elementTable.getExternalMapping(ownerMemberMetaData, MappingConsumer.MAPPING_TYPE_EXTERNAL_FK);
                    if (externalFKMapping != null)
                    {
                        // The element has an external FK mapping so set the value it needs to use in the INSERT
                        esm.setExternalFieldValueForMapping(externalFKMapping, sm.getObject());
                    }

View Full Code Here

0 1 2 3 4 5 6 7 8

TOP

Related Classes of org.jpox.store.mapped.DatastoreClass

org.jpox.state.JDOStateManagerImpl

org.jpox.store.mapped.expression.ClassExpression

org.jpox.store.mapped.expression.LogicSetExpression

org.jpox.store.mapped.expression.ObjectExpression

org.jpox.store.mapped.expression.ObjectLiteral

org.jpox.store.mapped.expression.TableExprAsJoins

org.jpox.store.mapped.expression.TableExprAsSubjoins

org.jpox.store.mapped.expression.UnboundVariable

org.jpox.store.mapped.mapping.AbstractMappingManager

org.jpox.store.mapped.mapping.PersistenceCapableMapping

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.