Package org.datanucleus.api

Examples of org.datanucleus.api.ApiAdapter


    public void storeObjectField(int fieldNumber, Object value)
    {
        if (value != null)
        {
            AbstractMemberMetaData mmd = sm.getClassMetaData().getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber);
            ApiAdapter api = sm.getExecutionContext().getApiAdapter();
            if (api.isPersistable(value))
            {
                // Process PC fields
                if (mmd.isDependent())
                {
                    processPersistable(value);
                }
            }
            else if (value instanceof Collection)
            {
                // Process all elements of the Collection that are PC
                boolean dependent = mmd.getCollection().isDependentElement();
                if (mmd.isCascadeRemoveOrphans())
                {
                    dependent = true;
                }
                if (mmd.hasCollection() && dependent)
                {
                    // Process any elements that are PersistenceCapable
                    Collection coll = (Collection)value;
                    Iterator iter = coll.iterator();
                    while (iter.hasNext())
                    {
                        Object element = iter.next();
                        if (api.isPersistable(element))
                        {
                            processPersistable(element);
                        }
                    }
                }
            }
            else if (value instanceof Map)
            {
                // Process all keys, values of the Map that are PC
                Map map = (Map)value;
                if (mmd.hasMap() && mmd.getMap().isDependentKey())
                {
                    // Process any keys that are PersistenceCapable
                    Set keys = map.keySet();
                    Iterator iter = keys.iterator();
                    while (iter.hasNext())
                    {
                        Object mapKey = iter.next();
                        if (api.isPersistable(mapKey))
                        {
                            processPersistable(mapKey);
                        }
                    }
                }
                if (mmd.hasMap() && mmd.getMap().isDependentValue())
                {
                    // Process any values that are PersistenceCapable
                    Collection values = map.values();
                    Iterator iter = values.iterator();
                    while (iter.hasNext())
                    {
                        Object mapValue = iter.next();
                        if (api.isPersistable(mapValue))
                        {
                            processPersistable(mapValue);
                        }
                    }
                }
            }
            else if (value instanceof Object[])
            {
                // Process all array elements that are PC
                if (mmd.hasArray() && mmd.getArray().isDependentElement())
                {
                    // Process any array elements that are PersistenceCapable
                    for (int i=0;i<Array.getLength(value);i++)
                    {
                        Object element = Array.get(value, i);
                        if (api.isPersistable(element))
                        {
                            processPersistable(element);
                        }
                    }
                }
View Full Code Here


        {
            getDatastoreMapping(0).setObject(ps, param[0], null);
        }
        else
        {
            ApiAdapter api = ec.getApiAdapter();
            OID oid;
            if (api.isPersistable(value))
            {
                oid = (OID) api.getIdForObject(value);
                if (oid == null)
                {
                    if (ec.isInserting(value))
                    {
                        // Object is in the process of being inserted, but has no id yet so provide a null for now
                        // The "NotYetFlushedException" is caught by ParameterSetter and processed as an update being required.
                        getDatastoreMapping(0).setObject(ps, param[0], null);
                        throw new NotYetFlushedException(value);
                    }
                    else
                    {
                        // Object is not persist, nor in the process of being made persistent
                        ec.persistObjectInternal(value, null, -1, ObjectProvider.PC);
                        ec.flushInternal(false);
                    }
                }
                oid = (OID) api.getIdForObject(value);
            }
            else
            {
                oid = (OID) value;
            }
View Full Code Here

     * @param fmd MetaData for the field storing this object
     */
    protected void processPersistable(Object obj, AbstractMemberMetaData fmd)
    {
        // TODO Remove this reference to PersistenceCabable
        ApiAdapter api = sm.getExecutionContext().getApiAdapter();
        ObjectProvider sm = this.sm.getExecutionContext().findObjectProvider(obj);
        if (sm != null)
        {
            sm.runReachability(reachables);
        }
        else
        {
            if (NucleusLogger.PERSISTENCE.isDebugEnabled())
            {
                NucleusLogger.PERSISTENCE.debug(LOCALISER.msg("007005",
                    api.getIdForObject(obj), fmd.getFullFieldName()));
            }
        }
    }
View Full Code Here

    {
        AbstractMemberMetaData fmd = sm.getClassMetaData().getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber);
        if (value != null)
        {
            boolean persistCascade = fmd.isCascadePersist();
            ApiAdapter api = sm.getExecutionContext().getApiAdapter();
            if (persistCascade)
            {
                if (api.isPersistable(value))
                {
                    // Process PC fields
                    if (NucleusLogger.PERSISTENCE.isDebugEnabled())
                    {
                        NucleusLogger.PERSISTENCE.debug(LOCALISER.msg("007004",
                            fmd.getFullFieldName()));
                    }
                    processPersistable(value, fmd);
                }
                else if (value instanceof Collection)
                {
                    // Process all elements of the Collection that are PC
                    if (NucleusLogger.PERSISTENCE.isDebugEnabled())
                    {
                        NucleusLogger.PERSISTENCE.debug(LOCALISER.msg("007002",
                            fmd.getFullFieldName()));
                    }
                    Collection coll = (Collection)value;
                    Iterator iter = coll.iterator();
                    while (iter.hasNext())
                    {
                        Object element = iter.next();
                        if (api.isPersistable(element))
                        {
                            processPersistable(element, fmd);
                        }
                    }
                }
                else if (value instanceof Map)
                {
                    // Process all keys, values of the Map that are PC
                    Map map = (Map)value;

                    // Process any keys that are PersistenceCapable
                    if (NucleusLogger.PERSISTENCE.isDebugEnabled())
                    {
                        NucleusLogger.PERSISTENCE.debug(LOCALISER.msg("007002",
                            fmd.getFullFieldName()));
                    }
                    Set keys = map.keySet();
                    Iterator iter = keys.iterator();
                    while (iter.hasNext())
                    {
                        Object mapKey = iter.next();
                        if (api.isPersistable(mapKey))
                        {
                            processPersistable(mapKey, fmd);
                        }
                    }

                    // Process any values that are PersistenceCapable
                    Collection values = map.values();
                    iter = values.iterator();
                    while (iter.hasNext())
                    {
                        Object mapValue = iter.next();
                        if (api.isPersistable(mapValue))
                        {
                            processPersistable(mapValue, fmd);
                        }
                    }
                }
                else if (value instanceof Object[])
                {
                    // Process all array elements that are PC
                    if (NucleusLogger.PERSISTENCE.isDebugEnabled())
                    {
                        NucleusLogger.PERSISTENCE.debug(LOCALISER.msg("007003",
                            fmd.getFullFieldName()));
                    }
                    Object[] array = (Object[]) value;
                    for (int i=0;i<array.length;i++)
                    {
                        Object element = array[i];
                        if (api.isPersistable(element))
                        {
                            processPersistable(element, fmd);
                        }
                    }
                }
View Full Code Here

    public Object fetchObjectField(int fieldNumber)
    {
        SingleValueFieldManager sfv = new SingleValueFieldManager();
        sm.provideFields(new int[]{fieldNumber}, sfv);
        Object value = sfv.fetchObjectField(fieldNumber);
        ApiAdapter api = sm.getExecutionContext().getApiAdapter();
        cachedPC.getLoadedFields()[fieldNumber] = true; // Overridden later if necessary

        if (value == null)
        {
            return null;
        }
        else
        {
            AbstractMemberMetaData mmd =
                sm.getClassMetaData().getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber);
            if (mmd.getPersistenceModifier() == FieldPersistenceModifier.TRANSACTIONAL)
            {
                // Cannot cache transactional fields
                cachedPC.getLoadedFields()[fieldNumber] = false;
                return null;
            }
            if (!mmd.isCacheable())
            {
                // Field is marked as not cacheable so unset its loaded flag and return null
                cachedPC.getLoadedFields()[fieldNumber] = false;
                return null;
            }

            if (api.isPersistable(value))
            {
                // 1-1, N-1 PC field
                if (mmd.isSerialized() || mmd.isEmbedded())
                {
                    // TODO Support serialised/embedded PC fields
                    cachedPC.getLoadedFields()[fieldNumber] = false;
                    return null;
                }

                // Put field OID in CachedPC "relationFields" and store null in this field
                cachedPC.setRelationField(mmd.getName(), api.getIdForObject(value));
                return null;
            }
            else if (value instanceof Collection)
            {
                // 1-N, M-N Collection
                if (MetaDataUtils.getInstance().storesPersistable(mmd, sm.getExecutionContext()))
                {
                    if (value instanceof List && mmd.getOrderMetaData() != null &&
                        !mmd.getOrderMetaData().isIndexedList())
                    {
                        // Ordered list so don't cache since dependent on datastore-retrieve order
                        cachedPC.getLoadedFields()[fieldNumber] = false;
                        return null;
                    }
                    if (mmd.isSerialized() || mmd.isEmbedded() ||
                        mmd.getCollection().isSerializedElement() || mmd.getCollection().isEmbeddedElement())
                    {
                        // TODO Support serialised/embedded elements
                        cachedPC.getLoadedFields()[fieldNumber] = false;
                        return null;
                    }
                    Collection collValue = (Collection)value;
                    if (collValue instanceof SCO && !((SCOContainer)value).isLoaded())
                    {
                        // Contents not loaded so just mark as unloaded
                        cachedPC.getLoadedFields()[fieldNumber] = false;
                        return null;
                    }

                    Iterator collIter = collValue.iterator();
                    Collection returnColl = null;
                    try
                    {
                        if (value.getClass().isInterface())
                        {
                            if (List.class.isAssignableFrom(value.getClass()) || mmd.getOrderMetaData() != null)
                            {
                                // List based
                                returnColl = new ArrayList();
                            }
                            else
                            {
                                // Set based
                                returnColl = new HashSet();
                            }
                        }
                        else
                        {
                            if (value instanceof SCO)
                            {
                                returnColl = (Collection)((SCO)value).getValue().getClass().newInstance();
                            }
                            else
                            {
                                returnColl = (Collection)value.getClass().newInstance();
                            }
                        }

                        // Recurse through elements, and put ids of elements in return value
                        while (collIter.hasNext())
                        {
                            Object elem = collIter.next();
                            if (elem == null)
                            {
                                returnColl.add(null); // Allow for null elements
                            }
                            else
                            {
                                returnColl.add(api.getIdForObject(elem));
                            }
                        }

                        // Put Collection<OID> in CachedPC "relationFields" and store null in this field
                        cachedPC.setRelationField(mmd.getName(), returnColl);
                        return null;
                    }
                    catch (Exception e)
                    {
                        NucleusLogger.CACHE.warn("Unable to create object of type " + value.getClass().getName() +
                            " for L2 caching : " + e.getMessage());

                        // Contents not loaded so just mark as unloaded
                        cachedPC.getLoadedFields()[fieldNumber] = false;
                        return null;
                    }
                }
                else
                {
                    // Collection<Non-PC> so just return it
                    if (value instanceof SCOContainer)
                    {
                        if (((SCOContainer)value).isLoaded())
                        {
                            // Return unwrapped collection
                            return ((SCO)value).getValue();
                        }
                        else
                        {
                            // Contents not loaded so just mark as unloaded
                            cachedPC.getLoadedFields()[fieldNumber] = false;
                            return null;
                        }
                    }
                    else
                    {
                        return value;
                    }
                }
            }
            else if (value instanceof Map)
            {
                // 1-N, M-N Map
                if (MetaDataUtils.getInstance().storesPersistable(mmd, sm.getExecutionContext()))
                {
                    if (mmd.isSerialized() || mmd.isEmbedded() ||
                        mmd.getMap().isSerializedKey() || mmd.getMap().isEmbeddedKey() ||
                        mmd.getMap().isSerializedValue() || mmd.getMap().isEmbeddedValue())
                    {
                        // TODO Support serialised/embedded keys/values
                        cachedPC.getLoadedFields()[fieldNumber] = false;
                        return null;
                    }

                    if (value instanceof SCO && !((SCOContainer)value).isLoaded())
                    {
                        // Contents not loaded so just mark as unloaded
                        cachedPC.getLoadedFields()[fieldNumber] = false;
                        return null;
                    }

                    try
                    {
                        Map returnMap = null;
                        if (value.getClass().isInterface())
                        {
                            returnMap = new HashMap();
                        }
                        else
                        {
                            if (value instanceof SCO)
                            {
                                returnMap = (Map)((SCO)value).getValue().getClass().newInstance();
                            }
                            else
                            {
                                returnMap = (Map)value.getClass().newInstance();
                            }
                        }
                        Iterator mapIter = ((Map)value).entrySet().iterator();
                        while (mapIter.hasNext())
                        {
                            Map.Entry entry = (Map.Entry)mapIter.next();
                            Object mapKey = null;
                            Object mapValue = null;
                            if (mmd.getMap().keyIsPersistent())
                            {
                                mapKey = api.getIdForObject(entry.getKey());
                            }
                            else
                            {
                                mapKey = entry.getKey();
                            }
                            if (mmd.getMap().valueIsPersistent())
                            {
                                mapValue = api.getIdForObject(entry.getValue());
                            }
                            else
                            {
                                mapValue = entry.getValue();
                            }
                            returnMap.put(mapKey, mapValue);
                        }

                        // Put Map<X, Y> in CachedPC "relationFields" and store null in this field
                        // where X, Y can be OID if they are persistable objects
                        cachedPC.setRelationField(mmd.getName(), returnMap);
                        return null;
                    }
                    catch (Exception e)
                    {
                        NucleusLogger.CACHE.warn("Unable to create object of type " + value.getClass().getName() +
                            " for L2 caching : " + e.getMessage());

                        // Contents not loaded so just mark as unloaded
                        cachedPC.getLoadedFields()[fieldNumber] = false;
                        return null;
                    }
                }
                else
                {
                    // Map<Non-PC, Non-PC> so just return it
                    if (value instanceof SCOContainer)
                    {
                        if (((SCOContainer)value).isLoaded())
                        {
                            // Return unwrapped map
                            return ((SCO)value).getValue();
                        }
                        else
                        {
                            // Contents not loaded so just mark as unloaded
                            cachedPC.getLoadedFields()[fieldNumber] = false;
                            return null;
                        }
                    }
                    else
                    {
                        return value;
                    }
                }
            }
            else if (value instanceof Object[])
            {
                // Array, maybe of Persistable objects
                if (MetaDataUtils.getInstance().storesPersistable(mmd, sm.getExecutionContext()))
                {
                    if (mmd.isSerialized() || mmd.isEmbedded() ||
                        mmd.getArray().isSerializedElement() || mmd.getArray().isEmbeddedElement())
                    {
                        // TODO Support serialised/embedded elements
                        cachedPC.getLoadedFields()[fieldNumber] = false;
                        return null;
                    }

                    Object[] returnArr = new Object[Array.getLength(value)];
                    for (int i=0;i<Array.getLength(value);i++)
                    {
                        Object element = Array.get(value, i);
                        returnArr[i] = api.getIdForObject(element);
                    }

                    // Put OID[] in CachedPC "relationFields" and store null in this field
                    cachedPC.setRelationField(mmd.getName(), returnArr);
                    return null;
View Full Code Here

                // Elements are embedded but no join table so we store in a single column
                singleColumn = true;
            }

            Class elementClass = fmd.getType().getComponentType();
            ApiAdapter api = mmgr.getApiAdapter();
            if (!elementClass.isInterface() && !api.isPersistable(elementClass))
            {
                // Array of non-PC with no join table  so store in single column of main table
                singleColumn = true;
            }
        }
View Full Code Here

     * @param ownerOP ObjectProvider for the owning object with the collection
     * @param elements The elements in the collection
     */
    public static void refreshFetchPlanFieldsForCollection(ObjectProvider ownerOP, Object[] elements)
    {
        ApiAdapter api = ownerOP.getExecutionContext().getApiAdapter();
        for (int i = 0; i < elements.length; i++)
        {
            if (api.isPersistable(elements[i]))
            {
                ownerOP.getExecutionContext().refreshObject(elements[i]);
            }
        }
    }
View Full Code Here

     * @param ownerOP ObjectProvider for the owning object with the map
     * @param entries The entries in the map
     */
    public static void refreshFetchPlanFieldsForMap(ObjectProvider ownerOP, Set entries)
    {
        ApiAdapter api = ownerOP.getExecutionContext().getApiAdapter();
        for (Iterator it = entries.iterator(); it.hasNext();)
        {
            Map.Entry entry = (Map.Entry) it.next();
            Object val = entry.getValue();
            Object key = entry.getKey();
            if (api.isPersistable(key))
            {
               ownerOP.getExecutionContext().refreshObject(key);
            }
            if (api.isPersistable(val))
            {
               ownerOP.getExecutionContext().refreshObject(val);
            }
        }
    }
View Full Code Here

     * @param elements The elements in the collection
     * @param state FetchPlan state
     */
    public static void detachForCollection(ObjectProvider ownerOP, Object[] elements, FetchPlanState state)
    {
        ApiAdapter api = ownerOP.getExecutionContext().getApiAdapter();
        for (int i = 0; i < elements.length; i++)
        {
            if (api.isPersistable(elements[i]))
            {
                ownerOP.getExecutionContext().detachObject(elements[i], state);
            }
        }
    }
View Full Code Here

     * @param state FetchPlan state
     * @param detached Collection to add the detached copies to
     */
    public static void detachCopyForCollection(ObjectProvider ownerOP, Object[] elements, FetchPlanState state, Collection detached)
    {
        ApiAdapter api = ownerOP.getExecutionContext().getApiAdapter();
        for (int i = 0; i < elements.length; i++)
        {
            if (elements[i] == null)
            {
                detached.add(null);
            }
            else
            {
                Object object = elements[i];
                if (api.isPersistable(object))
                {
                    detached.add(ownerOP.getExecutionContext().detachObjectCopy(object, state));
                }
                else
                {
View Full Code Here

TOP

Related Classes of org.datanucleus.api.ApiAdapter

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.