Examples with ObjectProvider org.datanucleus.state.ObjectProvider used on opensource projects

Example 66 with ObjectProvider

use of org.datanucleus.state.ObjectProvider in project datanucleus-api-jdo by datanucleus.

the class NucleusJDOHelper method getLoadedFields.

/**
 * Accessor for the names of the loaded fields of the persistable object.
 * @param obj Persistable object
 * @param pm The Persistence Manager (only required if the object is detached)
 * @return Names of the loaded fields
 */
public static String[] getLoadedFields(Object obj, PersistenceManager pm) {
    if (obj == null || !(obj instanceof Persistable)) {
        return null;
    }
    Persistable pc = (Persistable) obj;
    if (isDetached(pc)) {
        // Temporarily attach a StateManager to access the detached field information
        ExecutionContext ec = ((JDOPersistenceManager) pm).getExecutionContext();
        ObjectProvider op = ec.getNucleusContext().getObjectProviderFactory().newForDetached(ec, pc, getObjectId(pc), null);
        pc.dnReplaceStateManager(op);
        op.retrieveDetachState(op);
        String[] loadedFieldNames = op.getLoadedFieldNames();
        pc.dnReplaceStateManager(null);
        return loadedFieldNames;
    }
    ExecutionContext ec = ((JDOPersistenceManager) pm).getExecutionContext();
    ObjectProvider op = ec.findObjectProvider(pc);
    if (op == null) {
        return null;
    }
    return op.getLoadedFieldNames();
}

Example 67 with ObjectProvider

use of org.datanucleus.state.ObjectProvider in project datanucleus-api-jdo by datanucleus.

the class JDOCallbackHandler method preStore.

/**
 * Callback before the object is stored.
 * @param pc The Object
 */
public void preStore(Object pc) {
    for (LifecycleListenerForClass listener : getListenersWorkingCopy()) {
        if (listener.forClass(pc.getClass()) && listener.getListener() instanceof StoreLifecycleListener) {
            ExecutionContext ec = nucleusCtx.getApiAdapter().getExecutionContext(pc);
            String[] fieldNames = null;
            // PRE_STORE will return the fields being stored (DataNucleus extension)
            ObjectProvider op = ec.findObjectProvider(pc);
            fieldNames = op.getDirtyFieldNames();
            if (fieldNames == null) {
                // Must be persisting so just return all loaded fields
                fieldNames = op.getLoadedFieldNames();
            }
            ((StoreLifecycleListener) listener.getListener()).preStore(new FieldInstanceLifecycleEvent(pc, InstanceLifecycleEvent.STORE, null, fieldNames));
        }
    }
    if (pc instanceof StoreCallback) {
        try {
            ((StoreCallback) pc).jdoPreStore();
        } catch (Exception e) {
            throw new JDOUserCallbackException(Localiser.msg("025001", "jdoPreStore"), e);
        }
    }
    if (beanValidationHandler != null) {
        ObjectProvider op = nucleusCtx.getApiAdapter().getExecutionContext(pc).findObjectProvider(pc);
        if (!op.getLifecycleState().isNew()) {
            // Don't fire this when persisting new since we will have done prePersist
            beanValidationHandler.preStore(pc);
        }
    }
}

Example 68 with ObjectProvider

use of org.datanucleus.state.ObjectProvider in project datanucleus-rdbms by datanucleus.

the class RDBMSPersistenceHandler method locateObjects.

// ------------------------------ Locate ----------------------------------
public void locateObjects(ObjectProvider[] ops) {
    if (ops == null || ops.length == 0) {
        return;
    }
    ClassLoaderResolver clr = ops[0].getExecutionContext().getClassLoaderResolver();
    Map<DatastoreClass, List<ObjectProvider>> opsByTable = new HashMap<>();
    for (int i = 0; i < ops.length; i++) {
        AbstractClassMetaData cmd = ops[i].getClassMetaData();
        DatastoreClass table = getDatastoreClass(cmd.getFullClassName(), clr);
        // Use root table in hierarchy
        table = table.getBaseDatastoreClass();
        List<ObjectProvider> opList = opsByTable.get(table);
        if (opList == null) {
            opList = new ArrayList<>();
        }
        opList.add(ops[i]);
        opsByTable.put(table, opList);
    }
    Iterator<Map.Entry<DatastoreClass, List<ObjectProvider>>> tableIter = opsByTable.entrySet().iterator();
    while (tableIter.hasNext()) {
        Map.Entry<DatastoreClass, List<ObjectProvider>> entry = tableIter.next();
        DatastoreClass table = entry.getKey();
        List<ObjectProvider> tableOps = entry.getValue();
        // TODO This just uses the base table. Could change to use the most-derived table
        // which would permit us to join to supertables and load more fields during this process
        LocateBulkRequest req = new LocateBulkRequest(table);
        req.execute(tableOps.toArray(new ObjectProvider[tableOps.size()]));
    }
}

Example 69 with ObjectProvider

use of org.datanucleus.state.ObjectProvider in project datanucleus-rdbms by datanucleus.

the class ResultMetaDataROF method getObject.

/**
 * Accessor for the object(s) from the current row of the ResultSet.
 * @return The object(s) for this row of the ResultSet.
 */
public Object getObject() {
    List returnObjects = new ArrayList();
    // A). Process persistent types
    PersistentTypeMapping[] persistentTypes = queryResultMetaData.getPersistentTypeMappings();
    if (persistentTypes != null) {
        if (persistentTypeResultSetGetters == null) {
            persistentTypeResultSetGetters = new ResultSetGetter[persistentTypes.length];
        }
        int startColumnIndex = 0;
        for (int i = 0; i < persistentTypes.length; i++) {
            Set<String> columnsInThisType = new HashSet<>();
            AbstractMemberMetaData[] mmds = new AbstractMemberMetaData[columnNames.length];
            Map<String, AbstractMemberMetaData> fieldColumns = new HashMap<>();
            DatastoreClass dc = ((RDBMSStoreManager) ec.getStoreManager()).getDatastoreClass(persistentTypes[i].getClassName(), ec.getClassLoaderResolver());
            AbstractClassMetaData acmd = ec.getMetaDataManager().getMetaDataForClass(persistentTypes[i].getClassName(), ec.getClassLoaderResolver());
            Object id = null;
            // and two columns with similar names e.g "Col1" and "col1". Until that situation comes up we ignore it :-)
            for (int j = startColumnIndex; j < columnNames.length; j++) {
                if (columnsInThisType.contains(columnNames[j])) {
                    // already added this column, so must be another persistent type
                    startColumnIndex = j;
                    break;
                }
                boolean found = false;
                if (acmd.getIdentityType() == IdentityType.DATASTORE) {
                    JavaTypeMapping datastoreIdMapping = dc.getSurrogateMapping(SurrogateColumnType.DATASTORE_ID, false);
                    Column df = datastoreIdMapping.getDatastoreMapping(0).getColumn();
                    if (df.getIdentifier().getName().equalsIgnoreCase(columnNames[j])) {
                        // add +1 because result sets in jdbc starts with 1
                        int datastoreIdentityExpressionIndex = j + 1;
                        id = datastoreIdMapping.getObject(ec, rs, new int[] { datastoreIdentityExpressionIndex });
                        found = true;
                    }
                }
                for (int k = 0; k < acmd.getNoOfManagedMembers() + acmd.getNoOfInheritedManagedMembers() && !found; k++) {
                    AbstractMemberMetaData apmd = acmd.getMetaDataForManagedMemberAtAbsolutePosition(k);
                    if (persistentTypes[i].getColumnForField(apmd.getName()) != null) {
                        if (persistentTypes[i].getColumnForField(apmd.getName()).equalsIgnoreCase(columnNames[j])) {
                            fieldColumns.put(columnNames[j], apmd);
                            columnsInThisType.add(columnNames[j]);
                            mmds[j] = apmd;
                            found = true;
                        }
                    } else {
                        JavaTypeMapping mapping = dc.getMemberMapping(apmd);
                        for (int l = 0; l < mapping.getDatastoreMappings().length && !found; l++) {
                            Column df = mapping.getDatastoreMapping(l).getColumn();
                            if (df.getIdentifier().getName().equalsIgnoreCase(columnNames[j])) {
                                fieldColumns.put(columnNames[j], apmd);
                                columnsInThisType.add(columnNames[j]);
                                mmds[j] = apmd;
                                found = true;
                            }
                        }
                    }
                }
                if (!columnsInThisType.contains(columnNames[j])) {
                    // column not found in this type, so must be another persistent type
                    startColumnIndex = j;
                    break;
                }
            }
            // Build fields and mappings in the results
            StatementMappingIndex[] stmtMappings = new StatementMappingIndex[acmd.getNoOfManagedMembers() + acmd.getNoOfInheritedManagedMembers()];
            Set<AbstractMemberMetaData> resultMmds = new HashSet<>();
            resultMmds.addAll(fieldColumns.values());
            int[] resultFieldNumbers = new int[resultMmds.size()];
            int j = 0;
            for (AbstractMemberMetaData apmd : resultMmds) {
                StatementMappingIndex stmtMapping = new StatementMappingIndex(dc.getMemberMapping(apmd));
                resultFieldNumbers[j] = apmd.getAbsoluteFieldNumber();
                List indexes = new ArrayList();
                for (int k = 0; k < mmds.length; k++) {
                    if (mmds[k] == apmd) {
                        indexes.add(Integer.valueOf(k));
                    }
                }
                int[] indxs = new int[indexes.size()];
                for (int k = 0; k < indxs.length; k++) {
                    // add +1 because result sets in JDBC starts with 1
                    indxs[k] = ((Integer) indexes.get(k)).intValue() + 1;
                }
                stmtMapping.setColumnPositions(indxs);
                stmtMappings[resultFieldNumbers[j]] = stmtMapping;
                j++;
            }
            Object obj = null;
            Class type = ec.getClassLoaderResolver().classForName(persistentTypes[i].getClassName());
            if (acmd.getIdentityType() == IdentityType.APPLICATION) {
                if (persistentTypeResultSetGetters[i] == null) {
                    final StatementClassMapping resultMappings = new StatementClassMapping();
                    for (int k = 0; k < resultFieldNumbers.length; k++) {
                        resultMappings.addMappingForMember(resultFieldNumbers[k], stmtMappings[resultFieldNumbers[k]]);
                    }
                    persistentTypeResultSetGetters[i] = new ResultSetGetter(ec, rs, resultMappings, acmd);
                }
                ResultSetGetter rsGetter = persistentTypeResultSetGetters[i];
                // TODO Make use of discriminator like in PersistentClassROF and set the pcClass in this?
                id = IdentityUtils.getApplicationIdentityForResultSetRow(ec, acmd, type, false, rsGetter);
                obj = ec.findObject(id, new FieldValues() {

                    public void fetchFields(ObjectProvider op) {
                        rsGetter.setObjectProvider(op);
                        op.replaceFields(resultFieldNumbers, rsGetter, false);
                    }

                    public void fetchNonLoadedFields(ObjectProvider op) {
                        rsGetter.setObjectProvider(op);
                        op.replaceNonLoadedFields(resultFieldNumbers, rsGetter);
                    }

                    public FetchPlan getFetchPlanForLoading() {
                        return null;
                    }
                }, type, ignoreCache, false);
            } else if (acmd.getIdentityType() == IdentityType.DATASTORE) {
                if (persistentTypeResultSetGetters[i] == null) {
                    final StatementClassMapping resultMappings = new StatementClassMapping();
                    for (int k = 0; k < resultFieldNumbers.length; k++) {
                        resultMappings.addMappingForMember(resultFieldNumbers[k], stmtMappings[resultFieldNumbers[k]]);
                    }
                    persistentTypeResultSetGetters[i] = new ResultSetGetter(ec, rs, resultMappings, acmd);
                }
                ResultSetGetter rsGetter = persistentTypeResultSetGetters[i];
                obj = ec.findObject(id, new FieldValues() {

                    public void fetchFields(ObjectProvider op) {
                        rsGetter.setObjectProvider(op);
                        op.replaceFields(resultFieldNumbers, rsGetter, false);
                    }

                    public void fetchNonLoadedFields(ObjectProvider op) {
                        rsGetter.setObjectProvider(op);
                        op.replaceNonLoadedFields(resultFieldNumbers, rsGetter);
                    }

                    public FetchPlan getFetchPlanForLoading() {
                        return null;
                    }
                }, type, ignoreCache, false);
            } else {
                // TODO Handle non-durable
                NucleusLogger.QUERY.warn("We do not currently support non-durable objects in the results of this type of query.");
            }
            returnObjects.add(obj);
        }
    }
    // B). Process simple columns
    String[] columns = queryResultMetaData.getScalarColumns();
    if (columns != null) {
        for (int i = 0; i < columns.length; i++) {
            try {
                Object obj = rs.getObject(columns[i]);
                returnObjects.add(obj);
            } catch (SQLException sqe) {
                String msg = Localiser.msg("059027", sqe.getMessage());
                NucleusLogger.QUERY.error(msg);
                throw new NucleusUserException(msg, sqe);
            }
        }
    }
    // C). Process constructor type mappings
    ConstructorTypeMapping[] ctrTypeMappings = queryResultMetaData.getConstructorTypeMappings();
    if (ctrTypeMappings != null) {
        for (int i = 0; i < ctrTypeMappings.length; i++) {
            String ctrClassName = ctrTypeMappings[i].getClassName();
            Class ctrCls = ec.getClassLoaderResolver().classForName(ctrClassName);
            List<ConstructorTypeColumn> ctrColumns = ctrTypeMappings[i].getColumnsForConstructor();
            Class[] ctrArgTypes = null;
            Object[] ctrArgVals = null;
            if (ctrColumns != null && ctrColumns.size() > 0) {
                int j = 0;
                ctrArgTypes = new Class[ctrColumns.size()];
                ctrArgVals = new Object[ctrColumns.size()];
                Iterator<ConstructorTypeColumn> colIter = ctrColumns.iterator();
                while (colIter.hasNext()) {
                    ConstructorTypeColumn ctrCol = colIter.next();
                    try {
                        Object colVal = rs.getObject(ctrCol.getColumnName());
                        ctrArgTypes[j] = colVal.getClass();
                        if (ctrCol.getJavaType() != null) {
                            // Attempt to convert to the type requested
                            ctrArgTypes[j] = ctrCol.getJavaType();
                            ctrArgVals[j] = TypeConversionHelper.convertTo(colVal, ctrArgTypes[j]);
                        } else {
                            ctrArgTypes[j] = colVal.getClass();
                            ctrArgVals[j] = colVal;
                        }
                    } catch (SQLException sqle) {
                    // TODO Handle this
                    }
                    j++;
                }
            }
            returnObjects.add(ClassUtils.newInstance(ctrCls, ctrArgTypes, ctrArgVals));
        }
    }
    if (returnObjects.size() == 0) {
        // No objects so user must have supplied incorrect MetaData
        return null;
    } else if (returnObjects.size() == 1) {
        // Return Object
        return returnObjects.get(0);
    } else {
        // Return Object[]
        return returnObjects.toArray(new Object[returnObjects.size()]);
    }
}

Example 70 with ObjectProvider

use of org.datanucleus.state.ObjectProvider in project datanucleus-rdbms by datanucleus.

the class ScrollableQueryResult method getObjectForIndex.

/**
 * Accessor for the result object at an index.
 * If the object has already been processed will return that object,
 * otherwise will retrieve the object using the factory.
 * @param index The list index position
 * @return The result object
 */
protected E getObjectForIndex(int index) {
    if (resultsObjsByIndex != null) {
        // Caching objects, so check the cache for this index
        E obj = resultsObjsByIndex.get(index);
        if (obj != null) {
            // Already retrieved so return it
            return obj;
        }
    }
    if (rs == null) {
        throw new NucleusUserException("Results for query have already been closed. Perhaps you called flush(), closed the query, or ended a transaction");
    }
    try {
        // ResultSet is numbered 1, 2, ... N
        // List is indexed 0, 1, 2, ... N-1
        rs.absolute(index + 1);
        E obj = rof.getObject();
        JDBCUtils.logWarnings(rs);
        // Process any bulk loaded members
        if (bulkLoadedValueByMemberNumber != null) {
            ExecutionContext ec = query.getExecutionContext();
            Map<Integer, Object> memberValues = bulkLoadedValueByMemberNumber.get(api.getIdForObject(obj));
            if (memberValues != null) {
                ObjectProvider op = ec.findObjectProvider(obj);
                Iterator<Map.Entry<Integer, Object>> memberValIter = memberValues.entrySet().iterator();
                while (memberValIter.hasNext()) {
                    Map.Entry<Integer, Object> memberValueEntry = memberValIter.next();
                    op.replaceField(memberValueEntry.getKey(), memberValueEntry.getValue());
                }
                op.replaceAllLoadedSCOFieldsWithWrappers();
            }
        }
        if (resultsObjsByIndex != null) {
            // Put it in our cache, keyed by the list index
            resultsObjsByIndex.put(index, obj);
            if (resultIdsByPosition != null) {
                resultIdsByPosition.put(index, api.getIdForObject(obj));
            }
        }
        return obj;
    } catch (SQLException sqe) {
        throw api.getDataStoreExceptionForException(Localiser.msg("052601", sqe.getMessage()), sqe);
    }
}