private Object unmarshall(PersistentEntity persistentEntity, Long id, Map<String, Object> data) {

    log.debug("unmarshalling entity {}, props {}, {}", id, data);
    EntityAccess entityAccess = new EntityAccess(persistentEntity, persistentEntity.newInstance());
    entityAccess.setConversionService(persistentEntity.getMappingContext().getConversionService());
    entityAccess.setIdentifier(id);
    data.remove("__id__");

    for (PersistentProperty property :
        entityAccess.getPersistentEntity().getPersistentProperties()) {

      String propertyName = property.getName();
      if (property instanceof Simple) { // implicitly sets version property as well
        entityAccess.setProperty(propertyName, data.remove(propertyName));
        //            } else if (property instanceof OneToOne) {
        //                log.error("property " + property.getName() + " is of type " +
        // property.getClass().getSuperclass());
      } else if (property instanceof ToOne) {
        ToOne to = (ToOne) property;

        CypherResult cypherResult =
            getSession()
                .getNativeInterface()
                .execute(
                    CypherBuilder.findRelationshipEndpointIdsFor(to),
                    Collections.singletonMap("id", id));

        Map<String, Object> row = IteratorUtil.singleOrNull(cypherResult);
        if (row != null) {
          Long endpointId = (Long) row.get("id");
          entityAccess.setProperty(
              propertyName,
              getMappingContext()
                  .getProxyFactory()
                  .createProxy(session, to.getAssociatedEntity().getJavaClass(), endpointId));
        }
      } else if ((property instanceof OneToMany) || (property instanceof ManyToMany)) {

        LazyEnititySet lazyEnititySet =
            new LazyEnititySet(
                entityAccess,
                (Association) property,
                getMappingContext().getProxyFactory(),
                getSession());
        entityAccess.setProperty(propertyName, lazyEnititySet);

      } else {
        throw new IllegalArgumentException(
            "property $property.name is of type ${property.class.superclass}");
      }
    }

    if (!data.isEmpty()) {
      GroovyObject go = (GroovyObject) (entityAccess.getEntity());
      go.setProperty(Neo4jGormEnhancer.UNDECLARED_PROPERTIES, data);
    }

    firePostLoadEvent(entityAccess.getPersistentEntity(), entityAccess);
    return entityAccess.getEntity();
  }
  @Override
  protected DBObject createNewEntry(String family) {
    BasicDBObject dbo = new BasicDBObject();
    PersistentEntity persistentEntity = getPersistentEntity();
    if (!persistentEntity.isRoot()) {
      dbo.put(MONGO_CLASS_FIELD, persistentEntity.getDiscriminator());
    }

    return dbo;
  }
 public PersistentEntity getRootEntity() {
   if (isRoot() || getParentEntity() == null) {
     return this;
   }
   PersistentEntity parent = getParentEntity();
   while (!parent.isRoot()) {
     parent = parent.getParentEntity();
   }
   return parent;
 }
 private String getCollectionName(PersistentEntity persistentEntity, DBObject nativeEntry) {
   String collectionName;
   if (persistentEntity.isRoot()) {
     MongoSession mongoSession = (MongoSession) getSession();
     collectionName = mongoSession.getCollectionName(persistentEntity);
   } else {
     MongoSession mongoSession = (MongoSession) getSession();
     collectionName = mongoSession.getCollectionName(persistentEntity.getRootEntity());
   }
   return collectionName;
 }
 /**
  * Get hold of the GrailsDomainClassProperty represented by the targetClass' propertyName,
  * assuming targetClass corresponds to a GrailsDomainClass.
  */
 private static PersistentProperty getGrailsDomainClassProperty(
     AbstractHibernateDatastore datastore, Class<?> targetClass, String propertyName) {
   PersistentEntity grailsClass =
       datastore != null
           ? datastore.getMappingContext().getPersistentEntity(targetClass.getName())
           : null;
   if (grailsClass == null) {
     throw new IllegalArgumentException(
         "Unexpected: class is not a domain class:" + targetClass.getName());
   }
   return grailsClass.getPropertyByName(propertyName);
 }
 @Override
 public Serializable getObjectIdentifier(Object instance) {
   if (instance == null) return null;
   if (proxyHandler.isProxy(instance)) {
     return ((HibernateProxy) instance).getHibernateLazyInitializer().getIdentifier();
   }
   Class<?> type = instance.getClass();
   ClassPropertyFetcher cpf = ClassPropertyFetcher.forClass(type);
   final PersistentEntity persistentEntity =
       getMappingContext().getPersistentEntity(type.getName());
   if (persistentEntity != null) {
     return (Serializable)
         cpf.getPropertyValue(instance, persistentEntity.getIdentity().getName());
   }
   return null;
 }
  @Override
  @SuppressWarnings({"rawtypes", "unchecked"})
  public Family createMappedForm(PersistentEntity entity) {
    ClassPropertyFetcher cpf = ClassPropertyFetcher.forClass(entity.getJavaClass());
    final Closure value = cpf.getStaticPropertyValue(GormProperties.MAPPING, Closure.class);
    if (value == null) {
      return new Region();
    }

    final Region family = new Region();
    AttributesFactory factory =
        new AttributesFactory() {
          @SuppressWarnings("unused")
          public void setRegion(String name) {
            family.setRegion(name);
          }
        };
    factory.setDataPolicy(defaultDataPolicy);

    MappingConfigurationBuilder builder = new MappingConfigurationBuilder(factory, KeyValue.class);
    builder.evaluate(value);
    entityToPropertyMap.put(entity, builder.getProperties());
    final RegionAttributes regionAttributes = factory.create();
    family.setRegionAttributes(regionAttributes);
    family.setCacheListeners(regionAttributes.getCacheListeners());
    family.setDataPolicy(regionAttributes.getDataPolicy());
    family.setCacheLoader(regionAttributes.getCacheLoader());
    family.setCacheWriter(regionAttributes.getCacheWriter());

    builder = new MappingConfigurationBuilder(family, KeyValue.class);
    builder.evaluate(value);
    return family;
  }
  @Override
  public Object invokeMethod(String name, Object obj) {
    Object[] args = obj.getClass().isArray() ? (Object[]) obj : new Object[] {obj};

    if (isCriteriaConstructionMethod(name, args)) {

      initializeQuery();

      uniqueResult = false;

      invokeClosureNode(args[0]);

      Object result;
      if (!uniqueResult) {
        result = query.list();
      } else {
        result = query.singleResult();
      }
      query = null;
      return result;
    }

    MetaMethod metaMethod = getMetaClass().getMetaMethod(name, args);
    if (metaMethod != null) {
      return metaMethod.invoke(this, args);
    }

    metaMethod = queryMetaClass.getMetaMethod(name, args);
    if (metaMethod != null) {
      return metaMethod.invoke(query, args);
    }

    if (args.length == 1 && args[0] instanceof Closure) {

      final PersistentProperty property = persistentEntity.getPropertyByName(name);
      if (property instanceof Association) {
        Association association = (Association) property;
        Query previousQuery = query;
        PersistentEntity previousEntity = persistentEntity;

        Query associationQuery = null;
        try {
          associationQuery = query.createQuery(property.getName());
          if (associationQuery instanceof AssociationQuery) {
            previousQuery.add((Query.Criterion) associationQuery);
          }
          query = associationQuery;
          persistentEntity = association.getAssociatedEntity();
          invokeClosureNode(args[0]);
          return query;
        } finally {

          persistentEntity = previousEntity;
          query = previousQuery;
        }
      }
    }

    throw new MissingMethodException(name, getClass(), args);
  }
 /**
  * Returns mapped domain name (*unprefixed*) for the specified @{link PersistentEntity}.
  *
  * @param entity
  * @return
  */
 public static String getMappedDomainName(PersistentEntity entity) {
   @SuppressWarnings("unchecked")
   ClassMapping<SimpleDBDomainClassMappedForm> classMapping = entity.getMapping();
   SimpleDBDomainClassMappedForm mappedForm = classMapping.getMappedForm();
   String entityFamily = getFamily(entity, mappedForm);
   return entityFamily;
 }
  @Override
  protected void deleteEntity(PersistentEntity pe, Object obj) {
    EntityAccess entityAccess = createEntityAccess(pe, obj);
    if (cancelDelete(pe, entityAccess)) {
      return;
    }

    for (Association association : pe.getAssociations()) {
      if (association.isOwningSide() && association.doesCascade(CascadeType.REMOVE)) {
        log.debug("cascading delete for property " + association.getName());

        GraphPersistentEntity otherPersistentEntity =
            (GraphPersistentEntity) association.getAssociatedEntity();
        Object otherSideValue = entityAccess.getProperty(association.getName());
        if (association instanceof ToOne) {
          deleteEntity(otherPersistentEntity, otherSideValue);
        } else {
          deleteEntities(otherPersistentEntity, (Iterable) otherSideValue);
        }
      }
    }

    getCypherEngine()
        .execute(
            String.format(
                "MATCH (n:%s) WHERE n.__id__={id} OPTIONAL MATCH (n)-[r]-() DELETE r,n",
                ((GraphPersistentEntity) pe).getLabel()),
            Collections.singletonMap("id", entityAccess.getIdentifier()));

    firePostDeleteEvent(pe, entityAccess);
  }
 int calcInheritenceChain(PersistentEntity pe) {
   if (pe == null) {
     return 0;
   } else {
     return calcInheritenceChain(pe.getParentEntity()) + 1;
   }
 }
 public static List<String> getDatasourceNames(PersistentEntity domainClass) {
   final Entity mappedForm = domainClass.getMapping().getMappedForm();
   if (mappedForm instanceof Mapping) {
     Mapping mapping = (Mapping) mappedForm;
     return mapping.getDatasources();
   }
   return Collections.singletonList(Mapping.DEFAULT_DATA_SOURCE);
 }
  @Override
  protected List<Object> retrieveAllEntities(
      PersistentEntity persistentEntity, Iterable<Serializable> keys) {

    Query query = session.createQuery(persistentEntity.getJavaClass());

    PersistentProperty identity = persistentEntity.getIdentity();
    if (keys instanceof List) {
      List actualKeys = new ArrayList();
      Iterator iterator = keys.iterator();
      while (iterator.hasNext()) {
        Object key = iterator.next();
        Object id = getIdentifierForKey(key);
        actualKeys.add(id);
      }
      query.in(identity.getName(), actualKeys);
    } else {
      List<Serializable> keyList = new ArrayList<Serializable>();
      for (Serializable key : keys) {
        keyList.add(key);
      }
      query.in(identity.getName(), keyList);
    }

    List<Object> entityResults = new ArrayList<Object>();
    Iterator<Serializable> keyIterator = keys.iterator();
    Map<Serializable, Object> resultMap = new HashMap<Serializable, Object>();
    for (Object o : query.list()) {
      if (o instanceof DBObject) {
        DBObject dbo = (DBObject) o;
        o =
            createObjectFromNativeEntry(
                getPersistentEntity(), (Serializable) dbo.get(MONGO_ID_FIELD), dbo);
      }
      resultMap.put(getObjectIdentifier(o), o);
    }
    while (keyIterator.hasNext()) {
      Object key = getIdentifierForKey(keyIterator.next());
      ConversionService conversionService = getMappingContext().getConversionService();
      key = conversionService.convert(key, identity.getType());
      Object o = resultMap.get(key);
      entityResults.add(o); // may add null, so entityResults list size matches input list size.
    }

    return entityResults;
  }
示例#14
0
 private static String getFamily(
     PersistentEntity persistentEntity, SimpleDBDomainClassMappedForm mappedForm) {
   String table = null;
   if (mappedForm != null) {
     table = mappedForm.getFamily();
   }
   if (table == null) table = persistentEntity.getJavaClass().getSimpleName();
   return table;
 }
  @SuppressWarnings("unchecked")
  @Override
  public Table createMappedForm(PersistentEntity entity) {
    Table table = super.createMappedForm(entity);
    CassandraPersistentEntity cassandraPersistentEntity = (CassandraPersistentEntity) entity;
    // read tableOptions
    ClassPropertyFetcher cpf = ClassPropertyFetcher.forClass(entity.getJavaClass());
    final Closure value = cpf.getStaticPropertyValue(TABLE_PROPERTIES, Closure.class);
    if (value != null) {
      MapConfigurationBuilder builder = new MapConfigurationBuilder();
      try {
        builder.evaluate(value);
      } catch (Exception e) {
        throw new IllegalMappingException(
            String.format("Error reading %s : %s", TABLE_PROPERTIES, e.toString()));
      }
      table.setTableProperties(builder.getProperties());
    }

    if (table.getKeyspace() == null) {
      table.setKeyspace(keyspace);
    }

    // additional static mapping block handling
    Map<String, Column> properties = entityToPropertyMap.get(entity);
    Object version = properties.get(MappingConfigurationBuilder.VERSION_KEY);
    if (version instanceof Boolean) {
      cassandraPersistentEntity.setVersion((Boolean) version);
    }

    Column idProperty = properties.get(IDENTITY_PROPERTY);
    Iterator<Entry<String, Column>> propertyIterator = properties.entrySet().iterator();

    while (propertyIterator.hasNext()) {
      Entry<String, Column> entry = propertyIterator.next();
      if (entry.getValue() instanceof Column) {
        String name = entry.getKey();
        Column column = entry.getValue();
        if (idProperty != null
            && idProperty.getName() != null
            && idProperty.getName().equals(name)) {
          // remove extra column created if id property in constraints block, as it conflicts with
          // the column created in mapping block.
          // constraints will be handled elsewhere in GORM
          propertyIterator.remove();
          continue;
        }

        if (column.getName() == null) {
          column.setName(name);
        }
        table.addColumn(column);
      }
    }

    return table;
  }
  protected void validatePropertyName(String propertyName, String methodName) {
    if (propertyName == null) {
      throw new IllegalArgumentException(
          "Cannot use [" + methodName + "] restriction with null property name");
    }

    PersistentProperty property = persistentEntity.getPropertyByName(propertyName);
    if (property == null && persistentEntity.getIdentity().getName().equals(propertyName)) {
      property = persistentEntity.getIdentity();
    }
    if (property == null) {
      throw new IllegalArgumentException(
          "Property ["
              + propertyName
              + "] is not a valid property of class ["
              + persistentEntity
              + "]");
    }
  }
  public static org.hibernate.criterion.DetachedCriteria getHibernateDetachedCriteria(
      AbstractHibernateQuery hibernateQuery, QueryableCriteria<?> queryableCriteria) {

    String alias = queryableCriteria.getAlias();
    PersistentEntity persistentEntity = queryableCriteria.getPersistentEntity();
    Class targetClass = persistentEntity.getJavaClass();
    org.hibernate.criterion.DetachedCriteria detachedCriteria;

    if (alias != null) {
      detachedCriteria = org.hibernate.criterion.DetachedCriteria.forClass(targetClass, alias);
    } else {
      detachedCriteria = org.hibernate.criterion.DetachedCriteria.forClass(targetClass);
    }
    populateHibernateDetachedCriteria(
        new HibernateQuery(detachedCriteria, persistentEntity),
        detachedCriteria,
        queryableCriteria);
    return detachedCriteria;
  }
  @Override
  protected void deleteEntities(
      PersistentEntity pe, @SuppressWarnings("rawtypes") Iterable objects) {
    List<EntityAccess> entityAccesses = new ArrayList<EntityAccess>();
    List<Object> ids = new ArrayList<Object>();
    Map<PersistentEntity, Collection<Object>> cascades =
        new HashMap<PersistentEntity, Collection<Object>>();

    for (Object obj : objects) {
      EntityAccess entityAccess = createEntityAccess(pe, obj);
      if (cancelDelete(pe, entityAccess)) {
        return;
      }
      entityAccesses.add(entityAccess);
      ids.add(entityAccess.getIdentifier());

      // populate cascades
      for (Association association : pe.getAssociations()) {
        Object property = entityAccess.getProperty(association.getName());
        if (association.isOwningSide()
            && association.doesCascade(CascadeType.REMOVE)
            && (property != null)) {

          PersistentEntity associatedEntity = association.getAssociatedEntity();

          Collection<Object> cascadesForPersistentEntity = cascades.get(associatedEntity);
          if (cascadesForPersistentEntity == null) {
            cascadesForPersistentEntity = new ArrayList<Object>();
            cascades.put(associatedEntity, cascadesForPersistentEntity);
          }

          if (association instanceof ToOne) {
            cascadesForPersistentEntity.add(property);
          } else {
            cascadesForPersistentEntity.addAll((Collection<?>) property);
          }
        }
      }
    }

    for (Map.Entry<PersistentEntity, Collection<Object>> entry : cascades.entrySet()) {
      deleteEntities(entry.getKey(), entry.getValue());
    }

    getCypherEngine()
        .execute(
            String.format(
                "MATCH (n:%s) WHERE n.__id__ in {ids} OPTIONAL MATCH (n)-[r]-() DELETE r,n",
                ((GraphPersistentEntity) pe).getLabel()),
            Collections.singletonMap("ids", ids));

    for (EntityAccess entityAccess : entityAccesses) {
      firePostDeleteEvent(pe, entityAccess);
    }
  }
 @Override
 protected PersistentEntity discriminatePersistentEntity(
     PersistentEntity persistentEntity, DBObject nativeEntry) {
   final Object o = nativeEntry.get(MONGO_CLASS_FIELD);
   if (o != null) {
     final String className = o.toString();
     final PersistentEntity childEntity =
         getMappingContext()
             .getChildEntityByDiscriminator(persistentEntity.getRootEntity(), className);
     if (childEntity != null) {
       return childEntity;
     }
   }
   return super.discriminatePersistentEntity(persistentEntity, nativeEntry);
 }
  @Override
  @SuppressWarnings("unchecked")
  public Identity<Column> createIdentity(
      PersistentEntity owner, MappingContext context, PropertyDescriptor pd) {
    final Table table = (Table) owner.getMapping().getMappedForm();
    if (table.hasCompositePrimaryKeys()) {
      return new Identity<Column>(owner, context, table.getPrimaryKeyNames()[0], Map.class) {
        PropertyMapping<Column> propertyMapping = createPropertyMapping(this, owner);

        public PropertyMapping<Column> getMapping() {
          return propertyMapping;
        }
      };
    }
    return super.createIdentity(owner, context, pd);
  }
  public MongoEntityPersister(
      MappingContext mappingContext,
      PersistentEntity entity,
      MongoSession mongoSession,
      ApplicationEventPublisher publisher) {
    super(mappingContext, entity, mongoSession, publisher);
    MongoDatastore datastore = (MongoDatastore) mongoSession.getDatastore();
    mongoTemplate = datastore.getMongoTemplate(entity);
    collectionName = datastore.getCollectionName(entity);

    if (!(entity instanceof EmbeddedPersistentEntity)) {

      PersistentProperty identity = entity.getIdentity();
      if (identity != null) {
        hasNumericalIdentifier = Long.class.isAssignableFrom(identity.getType());
        hasStringIdentifier = String.class.isAssignableFrom(identity.getType());
      }
    }
  }
 @Override
 protected MappingConfigurationBuilder createConfigurationBuilder(
     PersistentEntity entity, Mapping mapping) {
   return new HibernateMappingBuilder(mapping, entity.getName(), defaultConstraints);
 }
 public boolean isOwningEntity(PersistentEntity owner) {
   return domainClass.isOwningClass(owner.getJavaClass());
 }
 /**
  * @see #getPersistentProperties(Class, org.grails.datastore.mapping.model.MappingContext,
  *     org.grails.datastore.mapping.model.ClassMapping)
  */
 public List<PersistentProperty> getPersistentProperties(
     PersistentEntity entity, MappingContext context, ClassMapping classMapping) {
   return getPersistentProperties(entity.getJavaClass(), context, classMapping);
 }
  @Override
  public CassandraPersistentProperty createPersistentProperty(
      Field field,
      PropertyDescriptor descriptor,
      CassandraPersistentEntity<?> owner,
      SimpleTypeHolder simpleTypeHolder) {
    PersistentEntity gormEntity = gormCassandraMappingContext.getPersistentEntity(owner.getName());
    final CassandraPersistentProperty property =
        super.createPersistentProperty(field, descriptor, owner, simpleTypeHolder);
    final CassandraPersistentProperty transientProperty =
        new BasicCassandraPersistentProperty(
            field, descriptor, owner, (CassandraSimpleTypeHolder) simpleTypeHolder) {
          public boolean isTransient() {
            return true;
          }
        };
    if (field == null && !property.usePropertyAccess()) {
      return transientProperty;
    }
    if (field != null && Modifier.isTransient(field.getModifiers())) {
      return transientProperty;
    }
    if (field != null && grails.core.GrailsDomainClassProperty.ERRORS.equals(field.getName())) {
      return transientProperty;
    }

    if (field != null && field.getType().equals(Errors.class)) {
      return transientProperty;
    }

    if (field != null
        && (field.getName().contains(INTERNAL_MARKER)
            || field.getName().startsWith(INTERNAL_GRAILS_FIELD_MARKER))) {
      return transientProperty;
    }

    if (descriptor != null
        && descriptor.getWriteMethod() == null
        && descriptor.getReadMethod() == null) {
      return transientProperty;
    }

    Class<?> rawType =
        field != null ? field.getType() : descriptor != null ? descriptor.getPropertyType() : null;
    if (rawType == null) {
      return transientProperty;
    }
    if (rawType.isEnum()) {
      // persist as a string
      return new BasicCassandraPersistentProperty(
          field, descriptor, owner, (CassandraSimpleTypeHolder) simpleTypeHolder) {
        public com.datastax.driver.core.DataType getDataType() {
          return CassandraSimpleTypeHolder.getDataTypeFor(String.class);
        };

        public java.lang.Class<?> getType() {
          return String.class;
        };

        public boolean usePropertyAccess() {
          return true;
        };
      };
    } else if (URL.class.isAssignableFrom(rawType)
        || TimeZone.class.isAssignableFrom(rawType)
        || Locale.class.isAssignableFrom(rawType)
        || Currency.class.isAssignableFrom(rawType)
        || Calendar.class.isAssignableFrom(rawType)) {
      // persist as a string
      return new BasicCassandraPersistentProperty(
          field, descriptor, owner, (CassandraSimpleTypeHolder) simpleTypeHolder) {
        public com.datastax.driver.core.DataType getDataType() {
          return CassandraSimpleTypeHolder.getDataTypeFor(String.class);
        };

        public java.lang.Class<?> getType() {
          return String.class;
        };

        public boolean isEntity() {
          return false;
        };

        public boolean usePropertyAccess() {
          return true;
        };
      };
    } else if (field != null
        && GrailsDomainClassProperty.VERSION.equals(field.getName())
        && !gormEntity.isVersioned()) {
      return transientProperty;
    }

    // for collections or maps of non-primitive types, i.e associations,
    // return transient property as spring data cassandra doesn't support
    if (!property.isTransient()) {
      if (property.isMap() || property.isCollectionLike()) {
        try {
          property.getDataType();
        } catch (InvalidDataAccessApiUsageException e) {
          return transientProperty;
        }
      }
    }
    return property;
  }
  private void persistAssociationsOfEntity(
      PersistentEntity pe, EntityAccess entityAccess, boolean isUpdate) {

    Object obj = entityAccess.getEntity();
    DirtyCheckable dirtyCheckable = null;
    if (obj instanceof DirtyCheckable) {
      dirtyCheckable = (DirtyCheckable) obj;
    }

    for (PersistentProperty pp : pe.getAssociations()) {
      if ((!isUpdate) || ((dirtyCheckable != null) && dirtyCheckable.hasChanged(pp.getName()))) {

        Object propertyValue = entityAccess.getProperty(pp.getName());

        if ((pp instanceof OneToMany) || (pp instanceof ManyToMany)) {
          Association association = (Association) pp;

          if (propertyValue != null) {

            if (association.isBidirectional()) { // Populate other side of bidi
              for (Object associatedObject : (Iterable) propertyValue) {
                EntityAccess assocEntityAccess =
                    createEntityAccess(association.getAssociatedEntity(), associatedObject);
                assocEntityAccess.setProperty(association.getReferencedPropertyName(), obj);
              }
            }

            Iterable targets = (Iterable) propertyValue;
            persistEntities(association.getAssociatedEntity(), targets);

            boolean reversed = RelationshipUtils.useReversedMappingFor(association);

            if (!reversed) {
              if (!(propertyValue instanceof LazyEnititySet)) {
                LazyEnititySet les =
                    new LazyEnititySet(
                        entityAccess,
                        association,
                        getMappingContext().getProxyFactory(),
                        getSession());
                les.addAll(targets);
                entityAccess.setProperty(association.getName(), les);
              }
            }
          }
        } else if (pp instanceof ToOne) {
          if (propertyValue != null) {
            ToOne to = (ToOne) pp;

            if (to.isBidirectional()) { // Populate other side of bidi
              EntityAccess assocEntityAccess =
                  createEntityAccess(to.getAssociatedEntity(), propertyValue);
              if (to instanceof OneToOne) {
                assocEntityAccess.setProperty(to.getReferencedPropertyName(), obj);
              } else {
                Collection collection =
                    (Collection) assocEntityAccess.getProperty(to.getReferencedPropertyName());
                if (collection == null) {
                  collection = new ArrayList();
                  assocEntityAccess.setProperty(to.getReferencedPropertyName(), collection);
                }
                if (!collection.contains(obj)) {
                  collection.add(obj);
                }
              }
            }

            persistEntity(to.getAssociatedEntity(), propertyValue);

            boolean reversed = RelationshipUtils.useReversedMappingFor(to);
            String relType = RelationshipUtils.relationshipTypeUsedFor(to);

            if (!reversed) {
              getSession()
                  .addPendingInsert(
                      new RelationshipPendingInsert(
                          entityAccess,
                          relType,
                          new EntityAccess(to.getAssociatedEntity(), propertyValue),
                          getCypherEngine()));
            }
          }
        } else {
          throw new IllegalArgumentException(
              "wtf don't know how to handle " + pp + "(" + pp.getClass() + ")");
        }
      }
    }
  }