Question

我正在使用Cosmos DB，并且具有一个具有以下简化结构的文档：

{
    "id1":"123",
    "stuff": [
        {
            "id2": "stuff",
            "a": {
                "b": {
                    "c": {
                        "d": [
                            {
                                "e": [
                                    {
                                        "id3": "things",
                                        "name": "animals",
                                        "classes": [
                                            {
                                                "name": "ostrich",
                                                "meta": 1
                                            },
                                            {
                                                "name": "big ostrich",
                                                "meta": 1
                                            }
                                        ]
                                    },
                                    {
                                        "id3": "default",
                                        "name": "other",
                                        "classes": [
                                            {
                                                "name": "green trees",
                                                "meta": 1
                                            },
                                            {
                                                "name": "trees",
                                                "score": 1
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    }
                }
            }
        }
    ]
}

我的问题是-我有这些文档的数组，需要搜索name以查看它是否与我的搜索词匹配。例如，如果用户输入big trees，我希望trees和trees都返回。

因此，当前我将每个文档推入数组并执行以下操作：

For each文档

for each stuff

for each a.b.c.d[0].e

for each classes var splice = name.split(' ')

if (splice.includes(searchWord))

返回id1，id2和id3。

使用cosmosDB，我正在将SQL与以下代码配合使用：

client.queryDocuments(
    collection,
    `SELECT * FROM root r`
).toArray((err, results) => {stuff});

这有效地将集合中的每个文档带到一个数组中，以如上所述手动执行搜索。

当阵列中有1000或1,000,000个文档时，这会引起问题，我相信我应该利用Cosmos本身提供的搜索机制。有人能帮助我确定哪种SQL查询能够执行这种功能吗？

已经搜索了所有内容，是否还可以搜索5个最新文档？

感谢您提前获得任何见识！

Answer 1

1。有谁能帮助我确定哪些SQL查询能够执行这种功能？

嗨，JDT。根据您的示例和描述，建议您在cosmos db sql中使用ARRAY_CONTAINS。请参考我的示例：

样本文档：

[
    {
        "id1": "123",
        "stuff": [
            {
                "id2": "stuff",
                "a": {
                    "b": {
                        "c": {
                            "d": [
                                {
                                    "e": [
                                        {
                                            "id3": "things",
                                            "name": "animals",
                                            "classes": [
                                                {
                                                    "name": "ostrich",
                                                    "meta": 1
                                                },
                                                {
                                                    "name": "big ostrich",
                                                    "meta": 1
                                                }
                                            ]
                                        },
                                        {
                                            "id3": "default",
                                            "name": "other",
                                            "classes": [
                                                {
                                                    "name": "green trees",
                                                    "meta": 1
                                                },
                                                {
                                                    "name": "trees",
                                                    "score": 1
                                                }
                                            ]
                                        }
                                    ]
                                }
                            ]
                        }
                    }
                }
            }
        ]
    },
    {
        "id1": "456",
        "stuff": [
            {
                "id2": "stuff2",
                "a": {
                    "b": {
                        "c": {
                            "d": [
                                {
                                    "e": [
                                        {
                                            "id3": "things2",
                                            "name": "animals",
                                            "classes": [
                                                {
                                                    "name": "ostrich",
                                                    "meta": 1
                                                },
                                                {
                                                    "name": "trees",
                                                    "meta": 1
                                                }
                                            ]
                                        },
                                        {
                                            "id3": "default2",
                                            "name": "other",
                                            "classes": [
                                                {
                                                    "name": "green trees",
                                                    "meta": 1
                                                },
                                                {
                                                    "name": "trees",
                                                    "score": 1
                                                }
                                            ]
                                        }
                                    ]
                                }
                            ]
                        }
                    }
                }
            }
        ]
    },
    {
        "id1": "789",
        "stuff": [
            {
                "id2": "stuff3",
                "a": {
                    "b": {
                        "c": {
                            "d": [
                                {
                                    "e": [
                                        {
                                            "id3": "things3",
                                            "name": "animals",
                                            "classes": [
                                                {
                                                    "name": "ostrich",
                                                    "meta": 1
                                                },
                                                {
                                                    "name": "big",
                                                    "meta": 1
                                                }
                                            ]
                                        },
                                        {
                                            "id3": "default3",
                                            "name": "other",
                                            "classes": [
                                                {
                                                    "name": "big trees",
                                                    "meta": 1
                                                }
                                            ]
                                        }
                                    ]
                                }
                            ]
                        }
                    }
                }
            }
        ]
    }
]

查询：

SELECT distinct c.id1,stuff.id2,e.id3 FROM c
join stuff in c.stuff
join d in stuff.a.b.c.d
join e in  d.e
where ARRAY_CONTAINS(e.classes,{name:"trees"},true)
or ARRAY_CONTAINS(e.classes,{name:"big trees"},true)

输出：

2。搜索完所有内容后，还可以搜索最近的5个文件？

根据我的研究，到目前为止，LIMIT之类的功能在cosmos中均不受支持。但是，TOP受cosmos db支持。因此，如果您可以添加排序字段（例如日期或ID），则可以使用sql：

select top 5 from c order by c.sort desc

希望它对您有帮助。

SQL中的嵌套“ for循环”搜索-Azure CosmosDB

1 个答案: