Node.js 在无重复的情况下重新调整NEO4J中的复杂树状结构

我有一个方法

getPhotosInBucket

，它返回给定bucket中存在

[：IN]

关系的所有照片，其中每个照片都有自己与

Meta

节点的一组关系，每个节点都包含与不同版本的图像对应的属性，例如小型、中型、，缩略图等等。为了使事情更加复杂，每张照片也有一个创建者，每个创建者都有一个缩略图，就像照片有多个与其相关的

Meta

节点一样

下面是将返回的内容的简化版本。在本例中，只有一个用户创建了bucket并创建了每张照片，但在现实世界中，用户James可以拥有一个bucket，其中包含100个不同的图像，每个图像都有自己的创建者、缩略图和创建者缩略图

用于返回此数据的查询有点冗长，只是为了稍微演示一下我的结构并生成一个可视化图形：

    MATCH (album:Asset:Album:Bucket {name: 'Bucketjamesprivate'})
    MATCH (album)<-[:CREATED]-(creator)
    OPTIONAL MATCH (album)<-[:THUMBNAIL]-(albumThumb)<-[:META]-(albumThumbMeta)
    OPTIONAL MATCH (creator)<-[:THUMBNAIL]-(creatorThumb)
    OPTIONAL MATCH (creatorThumb)<-[:META]-(creatorThumbMeta)
    OPTIONAL MATCH (album)<-[:IN]-(photos)<-[:META]-(meta)
    OPTIONAL MATCH (photos)<-[:CREATED]-(photoOwner)<-[:THUMBNAIL]-(photoThumbnail)<-[:META]-(photoThumbnailMeta)
    RETURN DISTINCT album, albumThumb, albumThumbMeta, creator, creatorThumb, photos, meta, photoOwner, photoThumbnailMeta

无论是桶中的照片还是其他节点的缩略图，每个照片都只有少数元节点

我还想让前端的客户端对照片进行分页，是否有办法

限制

和

跳过

桶中的照片

我是否应该以不同的方式处理此问题并进行两次单独的交易？一个用来获取相册、相册拇指、创建者、创建者拇指，另一个用来获取照片和相关拇指
 我现在还有一点时间，让我试一试；）

我现在没有时间写更长的答案，但是如果你还没有写的话，你应该研究一下
WITH
子句。您可以进行一些匹配，传递一些值，并使用

在该

中执行一些
collect（）
ing，然后执行更多匹配、冲洗和重复。您好@BrianUnderwood感谢您的评论。我曾尝试将
与
和
collect（）
一起使用，但我发现奇怪的重复情况与此一样糟糕。我提出了类似的解决方案，但您的解决方案比我的要简洁得多。非常感谢。
    {
        album: {
            name: 'etc',
            foo: 'bar',
            bar: 'foo'
        },
        albumThumb: [
            {
                type: 'small',
                src: 'www.foo.com/small'
            },
            {
                type: 'medium',
                src: 'www.foo.com/medium'
            }
        ],
        creator: {
            name: 'James',
            foo: 'bar'
        },
        creatorThumb: [
            {
                type: 'small',
                src: 'www.foo.com/small'
            },
            {
                type: 'medium',
                src: 'www.foo.com/medium'
            }
        ],
        photos: [
            {
                photo: {
                    name: 'Photo 1',
                    date: '112432543636'
                },
                meta: [
                    {
                        type: 'small',
                        src: 'www.foo.com/small'
                    },
                    {
                        type: 'medium',
                        src: 'www.foo.com/medium'
                    }
                ],
                creator: {
                    name: 'James',
                    foo: 'bar'
                },
                creatorThumb: [
                    {
                        type: 'small',
                        src: 'www.foo.com/small'
                    },
                    {
                        type: 'medium',
                        src: 'www.foo.com/medium'
                    }
                ]
            },
            {
                photo: {
                    name: 'Photo 2',
                    date: '112432543636'
                },
                meta: [
                    {
                        type: 'small',
                        src: 'www.foo.com/small'
                    },
                    {
                        type: 'medium',
                        src: 'www.foo.com/medium'
                    }
                ],
                creator: {
                    name: 'James',
                    foo: 'bar'
                },
                creatorThumb: [
                    {
                        type: 'small',
                        src: 'www.foo.com/small'
                    },
                    {
                        type: 'medium',
                        src: 'www.foo.com/medium'
                    }
                ]
            }
        ]
    }

MATCH (album:Asset:Album:Bucket {name: 'Bucketjamesprivate'})
MATCH (album)<-[:CREATED]-(creator)
OPTIONAL MATCH (album)<-[:THUMBNAIL]-(albumThumb)<-[:META]-(albumThumbMeta)

WITH
  album,
  collect({src: albumThumb.src, type: albumThumbMeta.type}) AS albumThumbs,
  creator

OPTIONAL MATCH (creator)<-[:THUMBNAIL]-(creatorThumb)<-[:META]-(creatorThumbMeta)

WITH
  album,
  albumThumbs,
  creator,
  collect({src: creatorThumb.src, type: creatorThumbMeta.type}) AS creatorThumbs

OPTIONAL MATCH (album)<-[:IN]-(photo)<-[:META]-(photoMeta)
OPTIONAL MATCH
  (photo)<-[:CREATED]-(photoOwner)<-[:THUMBNAIL]-(ownerThumb)
  <-[:META]-(ownerThumbMeta)

WITH
  album,
  albumThumbs,
  creator,
  creatorThumbs,
  photo,
  collect({src: photo.src, type: photoMeta.type}) AS photoMeta,
  photoOwner,
  collect({src: ownerThumb.src, type: ownerThumbMeta.type}) AS ownerThumbs

RETURN
  album,
  albumThumbs,
  creator,
  creatorThumbs,
  collect({
    photo: photo,
    meta: photoMeta,
    owner: photoOwner,
    ownerThumbs: ownerThumbs}) AS photos

CREATE
  (bucket:Bucket {name: 'Bucketjamesprivate'})<-[:CREATED]-(james:Person {name: 'James'}),
  (p1:Photo)-[:IN]->(bucket),
  (p1)<-[:CREATED]-(james),
  (p1)<-[:META]-(:Meta {type: 'small'}),
  (p1)<-[:META]-(:Meta {type: 'medium'}),
  (p1)<-[:META]-(:Meta {type: 'small_sq'}),
  (p2:Photo)-[:IN]->(bucket),
  (p2)<-[:CREATED]-(james),
  (p2)<-[:META]-(:Meta {type: 'small'}),
  (p2)<-[:META]-(:Meta {type: 'medium'}),
  (p2)<-[:META]-(:Meta {type: 'small_sq'}),
  (bucket_thumb:Thumbnail)-[:THUMBNAIL]->(bucket),
  (bucket_thumb)<-[:CREATED]-(james),
  (bucket_thumb)<-[:META]-(:Meta {type: 'small'}),
  (bucket_thumb)<-[:META]-(:Meta {type: 'medium'}),
  (bucket_thumb)<-[:META]-(:Meta {type: 'small_sq'}),
  (james_thumb:Thumbnail)-[:THUMBNAIL]->(james),
  (james_thumb)<-[:CREATED]-(james),
  (james_thumb)<-[:META]-(:Meta {type: 'small'}),
  (james_thumb)<-[:META]-(:Meta {type: 'medium'}),
  (james_thumb)<-[:META]-(:Meta {type: 'small_sq'})