/** * Throw appropriate exception on attempt to flush an unmapped object. */ private static void throwFlushException(OpenJPAStateManager sm) { throw new InvalidStateException(_loc.get("flush-virtual", sm.getMetaData(), sm.getObjectId())). setFailedObject(sm.getManagedInstance()). setFatal(true); } }
/** * Determine if the given field needs to be selected. */ private static boolean requiresSelect(FieldMapping fm, OpenJPAStateManager sm, BitSet fields, JDBCFetchConfiguration fetch) { if (fields != null) return fields.get(fm.getIndex()); if (sm != null && sm.getPCState() != PCState.TRANSIENT && sm.getLoaded().get(fm.getIndex())) return false; return fetch.requiresFetch(fm) == FetchConfiguration.FETCH_LOAD; }
private Object getValue(Embeddable embed, OpenJPAStateManager sm, int idx) { if (embed instanceof MaxEmbeddedLobFieldStrategy) { return ((MaxEmbeddedLobFieldStrategy)embed).getValue(sm); } return sm.fetch(idx); }
/** * Increment the version indicator in the given state manager. */ private static void incrementVersion(OpenJPAStateManager sm) { long version = 0; if (sm.getVersion() != null) version = ((Long) sm.getVersion()).longValue() + 1; sm.setNextVersion(version); }
public Object toRelationDataStoreValue(OpenJPAStateManager sm, Column col) { if (sm == null || sm.getObjectId() == null) return null; return sm.getMetaData().getDescribedType().getName() + ":" + sm.getObjectId().toString(); } }
/** * Set version information into the given state manager. */ protected void loadVersion(OpenJPAStateManager sm) { if (sm.getVersion() == null) sm.setVersion(getVersion()); }
public void store(OpenJPAStateManager sm) { storeVersion(sm); storeImplData(sm); FieldMetaData[] fmds = sm.getMetaData().getFields(); for (int i = 0; i < fmds.length; i++) { if (sm.getLoaded().get(i)) { storeField(sm, fmds[i]); storeImplData(sm, fmds[i], isLoaded(i)); } else if (!isLoaded(i)) storeIntermediate(sm, fmds[i]); } }
/** * Create a new cacheable instance for the given state manager. */ private DataCachePCData newPCData(OpenJPAStateManager sm, DataCache cache) { ClassMetaData meta = sm.getMetaData(); if (_gen != null) return (DataCachePCData) _gen.generatePCData(sm.getObjectId(), meta); return new DataCachePCDataImpl(sm.fetchObjectId(), meta, cache.getName()); }
/** * Load the data and version information for this object into the * given state manager. Only fields in the given bit set will be loaded. */ public void load(OpenJPAStateManager sm, BitSet fields, FetchConfiguration fetch) { if (sm.getVersion() == null) sm.setVersion(_version); FieldMetaData[] fmds = _meta.getFields(); for (int i = 0; i < fmds.length; i++) if (fields.get(i)) sm.store(i, toLoadable(sm, fmds[i], _data[i], fetch)); }
/** * Throw an inconsistency exception */ protected void throwException(OpenJPAStateManager sm, FieldMetaData fmd) { throw new InvalidStateException(_loc.get("inverse-consistency", fmd, sm.getId(), sm.getContext())).setFailedObject (sm.getManagedInstance()).setFatal(true); } }
/** * Gets the target slices for the given StateManager. */ public static SliceInfo getSlicesByPolicy(OpenJPAStateManager sm, DistributedConfiguration conf, Object ctx) { return getSlicesByPolicy(sm.getPersistenceCapable(), conf, ctx); }
public boolean assignField(OpenJPAStateManager sm, int field, boolean preFlush) { FieldMetaData fmd = sm.getMetaData().getField(field); Object val = ImplHelper.generateFieldValue(ctx, fmd); if (val == null) return false; sm.store(field, val); return true; }
public Object deriveKey(JDBCStore store, Object value) { OpenJPAStateManager sm = RelationStrategies.getStateManager(value, store.getContext()); return (sm == null) ? null : sm.fetchField(field.getKey(). getValueMappedByMetaData().getIndex(), false); }
/** * Collect the current versions of the given StateManagers. */ private Map<OpenJPAStateManager, Object> cacheVersion( List<OpenJPAStateManager> sms) { Map<OpenJPAStateManager, Object> result = new HashMap<OpenJPAStateManager, Object>(); for (OpenJPAStateManager sm : sms) result.put(sm, sm.getVersion()); return result; }
public Boolean isCustomInsert(OpenJPAStateManager sm, JDBCStore store) { OpenJPAStateManager em = sm.getContext().getStateManager(sm.fetchObject (field.getIndex())); Boolean custom = isCustom(INSERT, sm, em, store); if (Boolean.TRUE.equals(custom) && _synthetic) return null; return custom; }
/** * Log an inconsistency warning */ protected void warnConsistency(OpenJPAStateManager sm, FieldMetaData fmd) { if (_log.isWarnEnabled()) _log.warn(_loc.get("inverse-consistency", fmd, sm.getId(), sm.getContext())); }
/** * Transform the given data into an embedded PC field value. Default * implementation assumes the data is an {@link AbstractPCData}. */ protected Object toEmbeddedField(OpenJPAStateManager sm, ValueMetaData vmd, Object data, FetchConfiguration fetch, Object context) { AbstractPCData pcdata = (AbstractPCData) data; OpenJPAStateManager embedded = sm.getContext().embed(null, pcdata.getId(), sm, vmd); pcdata.load(embedded, (BitSet) pcdata.getLoaded().clone(), fetch, context); return embedded.getManagedInstance(); }
/** * Set intermediate information for the given field into the state manager. */ protected void loadIntermediate(OpenJPAStateManager sm, FieldMetaData fmd) { int index = fmd.getIndex(); Object inter = getIntermediate(index); if (inter != null && !sm.getLoaded().get(index)) sm.setIntermediate(index, inter); }
public boolean checkVersion(OpenJPAStateManager sm, JDBCStore store, boolean updateVersion) throws SQLException { if (updateVersion) sm.setVersion(null); return !updateVersion; }
/** * Make the given object embedded. */ private Object embed(ValueMetaData vmd, Object obj) { if (obj == null) return null; return _broker.embed(obj, null, _sm, vmd).getManagedInstance(); }