コード例 #1
0
  @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);
  }
コード例 #2
0
  @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);
    }
  }
 private void configureAssociation(
     GrailsDomainClassProperty grailsDomainClassProperty, final Association association) {
   association.setAssociatedEntity(
       getMappingContext()
           .addPersistentEntity(grailsDomainClassProperty.getReferencedPropertyType()));
   association.setOwningSide(grailsDomainClassProperty.isOwningSide());
   String referencedPropertyName = grailsDomainClassProperty.getReferencedPropertyName();
   if (referencedPropertyName != null) {
     association.setReferencedPropertyName(referencedPropertyName);
   } else {
     GrailsDomainClassProperty otherSide = grailsDomainClassProperty.getOtherSide();
     if (otherSide != null) {
       association.setReferencedPropertyName(otherSide.getName());
     }
   }
 }
コード例 #4
0
    public void index(final Object primaryKey, final List foreignKeys) {
      // if the association is a unidirectional one-to-many we store the keys
      // embedded in the owning entity, otherwise we use a foreign key
      if (!association.isBidirectional()) {
        mongoTemplate.execute(
            new DbCallback<Object>() {
              public Object doInDB(DB db) throws MongoException, DataAccessException {
                List dbRefs = new ArrayList();
                for (Object foreignKey : foreignKeys) {
                  if (isReference) {
                    dbRefs.add(
                        new DBRef(
                            db, getCollectionName(association.getAssociatedEntity()), foreignKey));
                  } else {
                    dbRefs.add(foreignKey);
                  }
                }
                nativeEntry.put(association.getName(), dbRefs);

                if (primaryKey != null) {
                  final DBCollection collection =
                      db.getCollection(getCollectionName(association.getOwner()));
                  DBObject query = new BasicDBObject(MONGO_ID_FIELD, primaryKey);
                  collection.update(query, nativeEntry);
                }
                return null;
              }
            });
      }
    }
コード例 #5
0
 private boolean isReference(Association association) {
   PropertyMapping mapping = association.getMapping();
   if (mapping != null) {
     MongoAttribute attribute = (MongoAttribute) mapping.getMappedForm();
     if (attribute != null) {
       return attribute.isReference();
     }
   }
   return true;
 }
コード例 #6
0
 @Override
 protected Object formulateDatabaseReference(
     PersistentEntity persistentEntity, Association association, Serializable associationId) {
   DB db = (DB) session.getNativeInterface();
   boolean isReference = isReference(association);
   if (isReference) {
     return new DBRef(db, getCollectionName(association.getAssociatedEntity()), associationId);
   }
   return associationId;
 }
コード例 #7
0
 @Override
 protected void setEmbeddedCollectionKeys(
     Association association,
     EntityAccess embeddedEntityAccess,
     DBObject embeddedEntry,
     List<Serializable> keys) {
   List dbRefs = new ArrayList();
   boolean reference = isReference(association);
   for (Object foreignKey : keys) {
     if (reference) {
       dbRefs.add(
           new DBRef(
               (DB) session.getNativeInterface(),
               getCollectionName(association.getAssociatedEntity()),
               foreignKey));
     } else {
       dbRefs.add(foreignKey);
     }
   }
   embeddedEntry.put(association.getName(), dbRefs);
 }
コード例 #8
0
  @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);
  }
コード例 #9
0
 public List query(Object primaryKey) {
   // for a unidirectional one-to-many we use the embedded keys
   if (!association.isBidirectional()) {
     final Object indexed = nativeEntry.get(association.getName());
     if (indexed instanceof Collection) {
       if (indexed instanceof List) return (List) indexed;
       return new ArrayList((Collection) indexed);
     }
     return Collections.emptyList();
   }
   // for a bidirectional one-to-many we use the foreign key to query the inverse side of the
   // association
   Association inverseSide = association.getInverseSide();
   Query query = session.createQuery(association.getAssociatedEntity().getJavaClass());
   query.eq(inverseSide.getName(), primaryKey);
   query.projections().id();
   return query.list();
 }
コード例 #10
0
  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() + ")");
        }
      }
    }
  }
コード例 #11
0
 public PersistentEntity getIndexedEntity() {
   return association.getAssociatedEntity();
 }
コード例 #12
0
  @Override
  public void run() {

    Map<String, Object> params = new LinkedHashMap<String, Object>(2);
    final Object parentId = getEntityAccess().getIdentifier();
    params.put(CypherBuilder.START, parentId);
    params.put(CypherBuilder.END, targetIdentifiers);

    final GraphPersistentEntity graphParent = (GraphPersistentEntity) getEntity();
    final GraphPersistentEntity graphChild =
        (GraphPersistentEntity) association.getAssociatedEntity();
    final boolean nativeParent = graphParent.getIdGenerator() == null;
    String labelsFrom = graphParent.getLabelsAsString();
    String labelsTo = graphChild.getLabelsAsString();

    final String relMatch;

    if (association instanceof DynamicToOneAssociation) {
      LinkedHashMap<String, String> attrs = new LinkedHashMap<String, String>();
      attrs.put(SOURCE_TYPE, graphParent.getJavaClass().getSimpleName());
      attrs.put(TARGET_TYPE, graphChild.getJavaClass().getSimpleName());
      relMatch = Neo4jQuery.matchForAssociation(association, "r", attrs);
    } else {
      relMatch = Neo4jQuery.matchForAssociation(association, "r");
    }

    boolean reversed = RelationshipUtils.useReversedMappingFor(association);
    if (!reversed && (association instanceof ToOne) && isUpdate) {
      // delete any previous

      String cypher;
      if (nativeParent) {
        cypher = String.format(CYPHER_DELETE_NATIVE_RELATIONSHIP, labelsFrom, relMatch);
      } else {
        cypher = String.format(CYPHER_DELETE_RELATIONSHIP, labelsFrom, relMatch);
      }

      if (log.isDebugEnabled()) {
        log.debug("DELETE Cypher [{}] for parameters [{}]", cypher, params);
      }
      graphDatabaseService.execute(cypher, Collections.singletonMap(CypherBuilder.START, parentId));
    }

    StringBuilder cypherQuery =
        new StringBuilder("MATCH (from")
            .append(labelsFrom)
            .append("), (to")
            .append(labelsTo)
            .append(") WHERE ");

    if (nativeParent) {
      cypherQuery.append("ID(from) = {start}");
    } else {
      cypherQuery.append("from.").append(CypherBuilder.IDENTIFIER).append(" = {start}");
    }
    cypherQuery.append(" AND ");
    if (graphChild.getIdGenerator() == null) {
      cypherQuery.append(" ID(to) IN {end} ");
    } else {
      cypherQuery.append("to.").append(CypherBuilder.IDENTIFIER).append(" IN {end}");
    }
    cypherQuery.append(" MERGE (from)").append(relMatch).append("(to)");

    String cypher = cypherQuery.toString();

    if (log.isDebugEnabled()) {
      log.debug("MERGE Cypher [{}] for parameters [{}]", cypher, params);
    }
    graphDatabaseService.execute(cypher, params);
  }