Package org.datanucleus.metadata

Examples of org.datanucleus.metadata.DiscriminatorMetaData


                {
                    // Add an empty inheritance specification
                    inhmd = new InheritanceMetaData();
                    cmd.setInheritanceMetaData(inhmd);
                }
                DiscriminatorMetaData dismd = inhmd.getDiscriminatorMetaData();
                if (dismd == null)
                {
                    // User hasn't specified discriminator value so use "provider-specific function" (JPA 9.1.3.1) - what a joke spec
                    dismd = inhmd.newDiscriminatorMetadata();
                    dismd.setStrategy(DiscriminatorStrategy.VALUE_MAP);
                    dismd.setValue(cmd.getFullClassName()); // Default to class name as value unless set
                    dismd.setIndexed("true");
                }
                String jdbcType = null;
                String discType = getAttr(attrs, "discriminator-type");
                if (discType != null)
                {
                    if (discType.equalsIgnoreCase("STRING"))
                    {
                        jdbcType = "VARCHAR";
                    }
                    else if (discType.equalsIgnoreCase("CHAR"))
                    {
                        jdbcType = "CHAR";
                    }
                    else if (discType.equalsIgnoreCase("INTEGER"))
                    {
                        jdbcType = "INTEGER";
                    }
                }
                ColumnMetaData colmd = new ColumnMetaData();
                colmd.setName(getAttr(attrs, "name"));
                colmd.setJdbcType(jdbcType);
                String columnDdl = getAttr(attrs, "column-definition");
                if (columnDdl != null)
                {
                    colmd.setColumnDdl(columnDdl);
                }
                dismd.setColumnMetaData(colmd);
            }
            else if (localName.equals("generated-value"))
            {
                // generated value for this field
                AbstractMemberMetaData fmd = (AbstractMemberMetaData)getStack();
View Full Code Here


                        // Add an empty inheritance specification
                        inhmd = new InheritanceMetaData();
                        cmd.setInheritanceMetaData(inhmd);
                    }
                    String discrimValue = currentString;
                    DiscriminatorMetaData dismd = inhmd.getDiscriminatorMetaData();
                    if (dismd == null)
                    {
                        dismd = inhmd.newDiscriminatorMetadata();
                    }
                    dismd.setValue(discrimValue);
                    dismd.setStrategy(DiscriminatorStrategy.VALUE_MAP);
                }
            }
            else if (localName.equals("column-name"))
            {
                if (md instanceof UniqueMetaData)
View Full Code Here

                        classMetaDataByEntityName.put(cmd.getEntityName(), cmd);
                    }
                    if (cmd.getInheritanceMetaData() != null)
                    {
                        // Register the metadata under the discriminator name
                        DiscriminatorMetaData dismd = cmd.getInheritanceMetaData().getDiscriminatorMetaData();
                        if (dismd != null)
                        {
                            if (dismd.getStrategy() == DiscriminatorStrategy.CLASS_NAME)
                            {
                                classMetaDataByDiscriminatorName.put(cmd.getFullClassName(), cmd);
                            }
                            else if (dismd.getStrategy() == DiscriminatorStrategy.VALUE_MAP)
                            {
                                classMetaDataByDiscriminatorName.put(dismd.getValue(), cmd);
                            }
                        }
                    }
                    registerMetaDataForClass(cmd.getFullClassName(), cmd);
View Full Code Here

    /* (non-Javadoc)
     * @see javax.jdo.metadata.InheritanceMetadata#getDiscriminatorMetaData()
     */
    public DiscriminatorMetadata getDiscriminatorMetadata()
    {
        DiscriminatorMetaData internalDismd = getInternal().getDiscriminatorMetaData();
        if (internalDismd == null)
        {
            return null;
        }
        DiscriminatorMetadataImpl dismd = new DiscriminatorMetadataImpl(internalDismd);
View Full Code Here

    /* (non-Javadoc)
     * @see javax.jdo.metadata.InheritanceMetadata#newDiscriminatorMetadata()
     */
    public DiscriminatorMetadata newDiscriminatorMetadata()
    {
        DiscriminatorMetaData internalDismd = getInternal().newDiscriminatorMetadata();
        DiscriminatorMetadataImpl dismd = new DiscriminatorMetadataImpl(internalDismd);
        dismd.parent = this;
        return dismd;
    }
View Full Code Here

            if (cmd != null)
            {
                // Class is persistable so process remaining annotations
                InheritanceMetaData inhmd = null;
                DiscriminatorMetaData dismd = null;
                IdentityMetaData idmd = null;
                PrimaryKeyMetaData pkmd = null;
                VersionMetaData vermd = null;
                JoinMetaData[] joins = null;
                QueryMetaData[] queries = null;
                FetchPlanMetaData[] fetchPlans = null;
                FetchGroupMetaData[] fetchGroups = null;
                SequenceMetaData seqmd = null;
                String cacheable = null;
                boolean embeddedOnly = false;
                ColumnMetaData[] unmappedColumns = null;
                HashSet<IndexMetaData> indices = null;
                HashSet<UniqueMetaData> uniqueKeys = null;
                HashSet<ForeignKeyMetaData> fks = null;
                HashSet<ExtensionMetaData> extensions = null;

                for (int i=0;i<annotations.length;i++)
                {
                    if (isSupportedAnnotation(annotations[i].getName()))
                    {
                        HashMap<String, Object> annotationValues = annotations[i].getNameValueMap();
                        String annName = annotations[i].getName();
                        if (annName.equals(JDOAnnotationUtils.EMBEDDED_ONLY))
                        {
                            embeddedOnly = true;
                        }
                        else if (annName.equals(JDOAnnotationUtils.VERSION))
                        {
                            VersionStrategy versionStrategy = (VersionStrategy)annotationValues.get("strategy");
                            String strategy = JDOAnnotationUtils.getVersionStrategyString(versionStrategy);
                            String indexed = (String)annotationValues.get("indexed");
                            String column = (String)annotationValues.get("column");
                            Column[] columns = (Column[])annotationValues.get("columns");
                            vermd = new VersionMetaData();
                            vermd.setStrategy(strategy);
                            vermd.setColumnName(column);
                            vermd.setIndexed(IndexedValue.getIndexedValue(indexed));
                            if (columns != null && columns.length > 0)
                            {
                                // Only use the first column
                                ColumnMetaData colmd =
                                    JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(columns[0]);
                                vermd.addColumn(colmd);
                            }
                            JDOAnnotationUtils.addExtensionsToMetaData(vermd, (Extension[])annotationValues.get("extensions"));
                        }
                        else if (annName.equals(JDOAnnotationUtils.DATASTORE_IDENTITY))
                        {
                            String strategy = JDOAnnotationUtils.getIdentityStrategyString(
                                (IdGeneratorStrategy)annotationValues.get("strategy"));
                            String customStrategy = (String)annotationValues.get("customStrategy");
                            if (!StringUtils.isWhitespace(customStrategy))
                            {
                                // User has provided an extension strategy
                                strategy = customStrategy;
                            }
                            String sequence = (String)annotationValues.get("sequence");
                            String column = (String)annotationValues.get("column");
                            Column[] columns = (Column[])annotationValues.get("columns");
                            idmd = new IdentityMetaData();
                            idmd.setColumnName(column);
                            idmd.setValueStrategy(IdentityStrategy.getIdentityStrategy(strategy));
                            idmd.setSequence(sequence);
                            if (columns != null && columns.length > 0)
                            {
                                // Only use the first column
                                ColumnMetaData colmd =
                                    JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(columns[0]);
                                idmd.addColumn(colmd);
                            }
                            JDOAnnotationUtils.addExtensionsToMetaData(idmd, (Extension[])annotationValues.get("extensions"));
                        }
                        else if (annName.equals(JDOAnnotationUtils.PRIMARY_KEY))
                        {
                            String pkName = (String)annotationValues.get("name");
                            String pkColumn = (String)annotationValues.get("column");
                            Column[] columns = (Column[])annotationValues.get("columns");
                            pkmd = new PrimaryKeyMetaData();
                            pkmd.setName(pkName);
                            pkmd.setColumnName(pkColumn);
                            if (columns != null && columns.length > 0)
                            {
                                for (int j=0;j<columns.length;j++)
                                {
                                    pkmd.addColumn(JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(columns[j]));
                                }
                            }
                        }
                        else if (annName.equals(JDOAnnotationUtils.JOINS))
                        {
                            if (joins != null)
                            {
                                NucleusLogger.METADATA.warn(LOCALISER.msg("044210", cmd.getFullClassName()));
                            }
                            Join[] js = (Join[])annotationValues.get("value");
                            if (js != null && js.length > 0)
                            {
                                joins = new JoinMetaData[js.length];
                                for (int j=0;j<js.length;j++)
                                {
                                    joins[j] = new JoinMetaData();
                                    joins[j].setTable(js[j].table());
                                    joins[j].setColumnName(js[j].column());
                                    joins[j].setIndexed(IndexedValue.getIndexedValue(js[i].indexed()));
                                    joins[j].setOuter(js[j].outer());
                                    joins[j].setUnique(js[i].unique());
                                    joins[j].setDeleteAction(JDOAnnotationUtils.getForeignKeyActionString(js[j].deleteAction()));
                                }
                            }
                        }
                        else if (annName.equals(JDOAnnotationUtils.JOIN))
                        {
                            if (joins != null)
                            {
                                NucleusLogger.METADATA.warn(LOCALISER.msg("044210", cmd.getFullClassName()));
                            }
                            joins = new JoinMetaData[1];
                            joins[0] = new JoinMetaData();
                            joins[0].setTable((String)annotationValues.get("table"));
                            joins[0].setColumnName((String)annotationValues.get("column"));
                            joins[0].setIndexed(IndexedValue.getIndexedValue((String)annotationValues.get("indexed")));
                            joins[0].setOuter((String)annotationValues.get("outer"));
                            joins[0].setUnique((String)annotationValues.get("unique"));
                            joins[0].setDeleteAction(((ForeignKeyAction)annotationValues.get("deleteAction")).toString());
                            JDOAnnotationUtils.addExtensionsToMetaData(joins[0], (Extension[])annotationValues.get("extensions"));
                        }
                        else if (annName.equals(JDOAnnotationUtils.INHERITANCE))
                        {
                            String strategy = JDOAnnotationUtils.getInheritanceStrategyString(
                                (InheritanceStrategy)annotationValues.get("strategy"));
                            String customStrategy = (String)annotationValues.get("customStrategy");
                            if (!StringUtils.isWhitespace(customStrategy))
                            {
                                // User has provided an extension strategy
                                strategy = customStrategy;
                            }
                            inhmd = new InheritanceMetaData();
                            inhmd.setStrategy(strategy);
                        }
                        else if (annName.equals(JDOAnnotationUtils.DISCRIMINATOR))
                        {
                            DiscriminatorStrategy discriminatorStrategy = (DiscriminatorStrategy)annotationValues.get("strategy");
                            String strategy = JDOAnnotationUtils.getDiscriminatorStrategyString(discriminatorStrategy);
                            String column = (String)annotationValues.get("column");
                            String indexed = (String)annotationValues.get("indexed");
                            String value = (String)annotationValues.get("value");
                            Column[] columns = (Column[])annotationValues.get("columns");
                            dismd = new DiscriminatorMetaData();
                            dismd.setColumnName(column);
                            dismd.setValue(value);
                            dismd.setStrategy(strategy);
                            dismd.setIndexed(indexed);
                            if (columns != null && columns.length > 0)
                            {
                                // Only use the first column
                                ColumnMetaData colmd =
                                    JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(columns[0]);
                                dismd.setColumnMetaData(colmd);
                            }
                        }
                        else if (annName.equals(JDOAnnotationUtils.QUERIES))
                        {
                            if (queries != null)
View Full Code Here

                if (discriminatorValue != null || discriminatorColumnName != null ||
                    discriminatorColumnLength != null || discriminatorColumnType != null)
                {
                    // Add discriminator information to the inheritance of this class
                    DiscriminatorMetaData dismd = inhmd.newDiscriminatorMetadata();
                    if (discriminatorValue != null)
                    {
                        // Value specified so assumed to be value-map
                        dismd.setColumnName(discriminatorColumnName);
                        dismd.setValue(discriminatorValue).setStrategy("value-map").setIndexed("false");
                    }
                    else
                    {
                        // No value so use class-name
                        discriminatorValue = cls.getName();
                        dismd.setColumnName(discriminatorColumnName);
                        dismd.setValue(discriminatorValue).setStrategy("value-map").setIndexed("false");
                    }

                    ColumnMetaData discolmd = null;
                    if (discriminatorColumnLength != null || discriminatorColumnName != null || discriminatorColumnType != null)
                    {
                        discolmd = new ColumnMetaData();
                        discolmd.setName(discriminatorColumnName);
                        if (discriminatorColumnType != null)
                        {
                            discolmd.setJdbcType(discriminatorColumnType);
                        }
                        if (discriminatorColumnLength != null)
                        {
                            discolmd.setLength(discriminatorColumnLength);
                        }
                        dismd.setColumnMetaData(discolmd);
                        if (discriminatorColumnDdl != null)
                        {
                            discolmd.setColumnDdl(discriminatorColumnDdl);
                        }
                    }
View Full Code Here

                    refString = value.getClass().getName() + ":" + sm.getInternalObjectId();
                }
                else if (mappingStrategy == XCALIA_MAPPING)
                {
                    AbstractClassMetaData cmd = sm.getClassMetaData();
                    DiscriminatorMetaData dismd = cmd.getDiscriminatorMetaDataForTable();
                    String definer = null;
                    if (dismd != null && dismd.getValue() != null)
                    {
                        definer = dismd.getValue();
                    }
                    else
                    {
                        definer = cmd.getFullClassName();
                    }
View Full Code Here

            boolean allowNull, DatastoreIdentifier candidateId)
    {
        QueryExpression stmt;

        JavaTypeMapping discriminatorMapping = null;
        DiscriminatorMetaData discriminatorMetaData = null;
        LogicSetExpression discriminatorTableExpr = null;
        if (sourceTableIsJoinTable())
        {
            // * Selecting the join table of a JoinTable relationship, and joining to the element table
            stmt = dba.newQueryStatement(sourceTable, candidateId, clr);
            IdentifierFactory idFactory = stmt.getStoreManager().getIdentifierFactory();

            // Add join from the join table to the root element table
            DatastoreIdentifier targetTableIdentifier = null;
            DatastoreIdentifier rootElementTblId = idFactory.newIdentifier(IdentifierType.TABLE, "ELEMENT");
            LogicSetExpression rootElementTblExpr = stmt.newTableExpression(candidateTable, rootElementTblId);
            ScalarExpression sourceExpr = sourceMapping.newScalarExpression(stmt, stmt.getMainTableExpression());
            ScalarExpression rootElementExpr =
                candidateTable.getIDMapping().newScalarExpression(stmt, rootElementTblExpr);
            if (allowNull)
            {
                stmt.leftOuterJoin(sourceExpr, rootElementExpr, rootElementTblExpr, true);
            }
            else
            {
                stmt.innerJoin(sourceExpr, rootElementExpr, rootElementTblExpr, true);
            }
            targetTableIdentifier = rootElementTblId;

            if (targetElementTable != candidateTable)
            {
                // Add join from the root element table to the target element table
                DatastoreIdentifier tgtElementTblId = idFactory.newIdentifier(IdentifierType.TABLE, "ELMNTSUB");
                LogicSetExpression tgtElementTblExpr = stmt.newTableExpression(targetElementTable, tgtElementTblId);
                ScalarExpression targetExpr =
                    targetElementTable.getIDMapping().newScalarExpression(stmt, tgtElementTblExpr);
                if (allowNull)
                {
                    stmt.leftOuterJoin(rootElementExpr, targetExpr, tgtElementTblExpr, true);
                }
                else
                {
                    stmt.innerJoin(rootElementExpr, targetExpr, tgtElementTblExpr, true);
                }
                targetTableIdentifier = tgtElementTblId;
            }

            discriminatorMapping = targetElementTable.getDiscriminatorMapping(false);
            discriminatorMetaData = targetElementTable.getDiscriminatorMetaData();
            discriminatorTableExpr = stmt.getTableExpression(targetTableIdentifier);

            // Add left outer joins to exclude any target element subclasses
            if (joinToExcludeTargetSubclasses)
            {
                joinToExcludeTargetWhenSubElementsExists(stmt, sourceMapping, targetElementType);
            }
        }
        else
        {
            // * Selecting FCO objects directly (Extents etc)
            // * Selecting the element table of a ForeignKey (inverse) relationship
            stmt = dba.newQueryStatement(candidateTable, candidateId, clr);

            discriminatorMapping = sourceTable.getDiscriminatorMapping(false);
            discriminatorMetaData = sourceTable.getDiscriminatorMetaData();
            discriminatorTableExpr = stmt.getMainTableExpression();

            // in case of the elementType is a subClass of the element for the candidateTable
            // if the root (candidate) element type is not the same as the current target element type
            // joins the root to the current element
            if ((!targetElementTable.toString().equals(sourceTable.toString()) &&
                 !candidateTable.getType().equals(targetElementType)) ||
                 sourceJoin)
            {
                // Add inner joins to all classes above up to elementType and across to the join table
                if (sourceJoin)
                {
                    joinTargetToSourceElement(stmt, targetElementTable, false);
                }
                else
                {
                    joinSourceToTargetElement(stmt, targetElementTable, false);
                }
            }
            if (joinToExcludeTargetSubclasses)
            {
                joinToExcludeTargetWhenSubElementsExists(stmt, candidateTable.getIDMapping(), targetElementType);
            }
        }

        if (discriminatorMapping != null && discriminatorMetaData.getStrategy() != DiscriminatorStrategy.NONE)
        {
            // Restrict to valid discriminator values where we have a discriminator specified on this table
            String discriminatorValue = targetElementType;
            if (discriminatorMetaData.getStrategy() == DiscriminatorStrategy.VALUE_MAP)
            {
                // Get the MetaData for the target class since that holds the "value"
                AbstractClassMetaData targetCmd = storeMgr.getOMFContext().getMetaDataManager().getMetaDataForClass(targetElementType, clr);
                discriminatorValue = targetCmd.getInheritanceMetaData().getDiscriminatorMetaData().getValue();
            }
View Full Code Here

    {
        initialize(dba, delegate.getType());
        this.datastoreContainer = datastoreContainer;
        this.delegate = delegate;

        DiscriminatorMetaData dismd = datastoreContainer.getDiscriminatorMetaData();
        IdentifierFactory idFactory = datastoreContainer.getStoreManager().getIdentifierFactory();
        DatastoreIdentifier id = null;
        if (dismd.getColumnMetaData() == null)
        {
            // No column name so generate a default
            id = idFactory.newDiscriminatorFieldIdentifier();
            ColumnMetaData colmd = new ColumnMetaData();
            colmd.setName(id.getIdentifierName());
            dismd.setColumnMetaData(colmd);
        }
        else
        {
            // Column metadata defined
            ColumnMetaData colmd = dismd.getColumnMetaData();
            if (colmd.getName() == null)
            {
                // No name defined so create one and set it
                id = idFactory.newDiscriminatorFieldIdentifier();
                colmd.setName(id.getIdentifierName());
            }
            else
            {
                // Name defined so just generate identifier
                id = idFactory.newDatastoreFieldIdentifier(colmd.getName());
            }
        }

        DatastoreField column = datastoreContainer.addDatastoreField(getType(), id, this, dismd.getColumnMetaData());
        datastoreContainer.getStoreManager().getMappingManager().createDatastoreMapping(delegate, column,
            getType());
    }
View Full Code Here

TOP

Related Classes of org.datanucleus.metadata.DiscriminatorMetaData

Copyright © 2018 www.massapicom. All rights reserved.
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.