| /***************************************************************** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| ****************************************************************/ |
| |
| package org.apache.cayenne.access; |
| |
| import java.util.Map; |
| |
| import org.apache.cayenne.DataRow; |
| import org.apache.cayenne.ObjectId; |
| import org.apache.cayenne.PersistenceState; |
| import org.apache.cayenne.Persistent; |
| import org.apache.cayenne.map.DbJoin; |
| import org.apache.cayenne.map.DbRelationship; |
| import org.apache.cayenne.map.ObjAttribute; |
| import org.apache.cayenne.map.ObjRelationship; |
| import org.apache.cayenne.reflect.ArcProperty; |
| import org.apache.cayenne.reflect.AttributeProperty; |
| import org.apache.cayenne.reflect.ClassDescriptor; |
| import org.apache.cayenne.reflect.PropertyVisitor; |
| import org.apache.cayenne.reflect.ToManyProperty; |
| import org.apache.cayenne.reflect.ToOneProperty; |
| import org.apache.cayenne.util.Util; |
| |
| /** |
| * DataRowUtils contains a number of static methods to work with DataRows. This is a |
| * helper class for DataContext and ObjectStore. |
| * |
| * @since 1.1 |
| */ |
| class DataRowUtils { |
| |
| /** |
| * Merges changes reflected in snapshot map to the object. Changes made to attributes |
| * and to-one relationships will be merged. In case an object is already modified, |
| * modified properties will not be overwritten. |
| */ |
| static void mergeObjectWithSnapshot( |
| DataContext context, |
| ClassDescriptor descriptor, |
| Persistent object, |
| DataRow snapshot) { |
| |
| int state = object.getPersistenceState(); |
| |
| if (state == PersistenceState.HOLLOW || descriptor.getEntity().isReadOnly()) { |
| refreshObjectWithSnapshot(descriptor, object, snapshot, true); |
| } |
| else if (state != PersistenceState.COMMITTED) { |
| forceMergeWithSnapshot(context, descriptor, object, snapshot); |
| } |
| else { |
| // do not invalidate to-many relationships, since they might have |
| // just been prefetched... |
| refreshObjectWithSnapshot(descriptor, object, snapshot, false); |
| } |
| } |
| |
| /** |
| * Replaces all object attribute values with snapshot values. Sets object state to |
| * COMMITTED, unless the snapshot is partial in which case the state is set to HOLLOW |
| */ |
| static void refreshObjectWithSnapshot( |
| ClassDescriptor descriptor, |
| final Persistent object, |
| final DataRow snapshot, |
| final boolean invalidateToManyRelationships) { |
| |
| final boolean[] isPartialSnapshot = new boolean[1]; |
| |
| descriptor.visitProperties(new PropertyVisitor() { |
| |
| public boolean visitAttribute(AttributeProperty property) { |
| ObjAttribute attr = property.getAttribute(); |
| String dbAttrPath = attr.getDbAttributePath(); |
| |
| Object value = snapshot.get(dbAttrPath); |
| property.writePropertyDirectly(object, null, value); |
| |
| // note that a check "snaphsot.get(..) == null" would be incorrect in this |
| // case, as NULL value is entirely valid; still save a map lookup by |
| // checking for the null value first |
| if (value == null && !snapshot.containsKey(dbAttrPath)) { |
| isPartialSnapshot[0] = true; |
| } |
| return true; |
| } |
| |
| public boolean visitToMany(ToManyProperty property) { |
| // "to many" relationships have no information to collect from |
| // snapshot |
| if (invalidateToManyRelationships) { |
| property.invalidate(object); |
| } |
| |
| return true; |
| } |
| |
| public boolean visitToOne(ToOneProperty property) { |
| property.invalidate(object); |
| return true; |
| } |
| }); |
| |
| object.setPersistenceState(isPartialSnapshot[0] |
| ? PersistenceState.HOLLOW |
| : PersistenceState.COMMITTED); |
| } |
| |
| static void forceMergeWithSnapshot( |
| final DataContext context, |
| ClassDescriptor descriptor, |
| final Persistent object, |
| final DataRow snapshot) { |
| |
| final ObjectDiff diff = context |
| .getObjectStore() |
| .getChangesByObjectId() |
| .get(object.getObjectId()); |
| |
| descriptor.visitProperties(new PropertyVisitor() { |
| |
| public boolean visitAttribute(AttributeProperty property) { |
| String dbAttrPath = property.getAttribute().getDbAttributePath(); |
| |
| // supports merging of partial snapshots... |
| // check for null is cheaper than double lookup |
| // for a key... so check for partial snapshot |
| // only if the value is null |
| Object newValue = snapshot.get(dbAttrPath); |
| if (newValue != null || snapshot.containsKey(dbAttrPath)) { |
| |
| Object curValue = property.readPropertyDirectly(object); |
| Object oldValue = diff != null ? diff.getSnapshotValue(property |
| .getName()) : null; |
| |
| // if value not modified, update it from snapshot, |
| // otherwise leave it alone |
| if (Util.nullSafeEquals(curValue, oldValue) |
| && !Util.nullSafeEquals(newValue, curValue)) { |
| property.writePropertyDirectly(object, oldValue, newValue); |
| } |
| } |
| return true; |
| } |
| |
| public boolean visitToMany(ToManyProperty property) { |
| // noop - nothing to merge |
| return true; |
| } |
| |
| public boolean visitToOne(ToOneProperty property) { |
| ObjRelationship relationship = property.getRelationship(); |
| if (relationship.isToPK()) { |
| // TODO: will this work for flattened, how do we save snapshots for |
| // them? |
| |
| // if value not modified, update it from snapshot, |
| // otherwise leave it alone |
| if (!isToOneTargetModified(property, object, diff)) { |
| |
| DbRelationship dbRelationship = relationship |
| .getDbRelationships() |
| .get(0); |
| |
| // must check before creating ObjectId because of partial |
| // snapshots |
| if (hasFK(dbRelationship, snapshot)) { |
| ObjectId id = snapshot.createTargetObjectId( |
| relationship.getTargetEntityName(), |
| dbRelationship); |
| |
| if (diff == null |
| || !diff.containsArcSnapshot(relationship.getName()) |
| || !Util.nullSafeEquals(id, diff |
| .getArcSnapshotValue(relationship.getName()))) { |
| |
| if (id == null) { |
| property.writeProperty(object, null, null); |
| } |
| else { |
| // we can't use 'localObject' if relationship is |
| // optional or inheritance is involved |
| // .. must turn to fault instead |
| if (!relationship |
| .isSourceDefiningTargetPrecenseAndType(context |
| .getEntityResolver())) { |
| property.invalidate(object); |
| } |
| else { |
| property.writeProperty( |
| object, |
| null, |
| context.findOrCreateObject(id)); |
| } |
| } |
| } |
| } |
| } |
| } |
| return true; |
| } |
| }); |
| } |
| |
| static boolean hasFK(DbRelationship relationship, Map<String, Object> snapshot) { |
| for (final DbJoin join : relationship.getJoins()) { |
| if (!snapshot.containsKey(join.getSourceName())) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Checks if an object has its to-one relationship target modified in memory. |
| */ |
| static boolean isToOneTargetModified( |
| ArcProperty property, |
| Persistent object, |
| ObjectDiff diff) { |
| |
| if (object.getPersistenceState() != PersistenceState.MODIFIED || diff == null) { |
| return false; |
| } |
| |
| if (property.isFault(object)) { |
| return false; |
| } |
| |
| Persistent toOneTarget = (Persistent) property.readPropertyDirectly(object); |
| ObjectId currentId = (toOneTarget != null) ? toOneTarget.getObjectId() : null; |
| |
| // if ObjectId is temporary, target is definitely modified... |
| // this would cover NEW objects (what are the other cases of temp id??) |
| if (currentId != null && currentId.isTemporary()) { |
| return true; |
| } |
| |
| if (!diff.containsArcSnapshot(property.getName())) { |
| return false; |
| } |
| |
| ObjectId targetId = diff.getArcSnapshotValue(property.getName()); |
| return !Util.nullSafeEquals(currentId, targetId); |
| } |
| |
| // not for instantiation |
| DataRowUtils() { |
| } |
| } |
