node.js - 在不重复的情况下重新调整 NEO4J 中的复杂树状结构

Question

我有一个方法 getPhotosInBucket，它返回给定存储桶中存在 [:IN] 关系的所有照片，其中每张照片都有自己的一组关系Meta Node ，每个 Node 都包含对应于不同版本图像的属性，例如。 small, medium, thumbnail 等等 让事情变得更复杂的是，每张照片还有一个创作者，每个创作者都有一个缩略图，就像照片有多个相关的 Meta Node 一样。

以下是将返回的内容的简化版本。在此示例中，只有一个用户创建了存储桶并创建了每张照片，但在现实世界中，用户 James 可能拥有一个包含 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

这最终会返回以下内容:

如您所见，James 创建了 1 个存储桶、1 个具有 3 个元 Node 的存储桶缩略图、存储桶中的 2 张照片，每张照片具有 3 个元 Node ，最后他创建了一个具有 3 个元 Node 的缩略图。

返回的实际行数是 54，当我在桶中只有少量照片要返回时，它只会呈指数增长，所以也许有一种更高效的方法来实现这一点。

我尝试过使用 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'
                    }
                ]
            }
        ]
    }

无论是存储桶中的照片还是作为其他 Node 缩略图的照片，每张照片都只有少数元 Node 。

我还想允许前端的客户端对照片进行分页，有什么办法可以LIMIT 和SKIP 照片 IN 桶？

我应该以不同的方式处理这个问题并进行 2 次单独的交易吗？一个获取相册、albumThumb、creator、creatorThumb，另一个获取照片和相关的拇指？

Answer 1

我现在还有更多时间，让我试一试 ;)

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 语句，顺便说一句，以防万一有人想试一试:

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'})