当前位置: 首页 > 知识库问答 >
问题:

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

车诚
2023-03-14

我正在使用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以查看它是否与我的搜索词匹配。例如,如果用户输入,我希望大树都返回。

所以目前我将每个文档推送到一个数组中并执行以下操作:

每个文档的

对于每个东西

对于每个a. b. c. d[0]. e

对于每个,var 拼接 = 名称.split(' ')

if(拼接。包括(搜索词))

返回< code>id1、< code>id2和< code>id3。

使用cosmosDB,我使用SQL,代码如下:

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

这有效地将集合中的每个文档放入一个数组中,以手动执行上述搜索。

当我在数组中有 1000 或 1,000,000 个文档时,这将导致问题,并且我相信我应该利用 Cosmos 本身中可用的搜索机制。有没有人能够帮助我弄清楚哪些SQL查询能够执行这种类型的功能?

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

提前感谢您的任何见解!

共有1个答案

胥诚
2023-03-14

1.Is 有人能够帮助我弄清楚什么SQL查询能够执行这种类型的功能?

根据你的示例和描述,建议你在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个最新文档?

根据我的研究,到目前为止,cosmos还不支持像< code>LIMIT这样的特性。但是,cosmos db支持< code>TOP。因此,如果您可以添加排序字段(如日期或id),那么您可以使用sql:

select top 5 from c order by c.sort desc
 类似资料:
  • 和其他编程语言一样, Java 允许循环嵌套。如果把一个循环放在另一个循环体内,那么就可以形成嵌套循环。 嵌套循环既可以是 for循环嵌套 while 循环,也可以是 while 循环嵌套 do-while 循环 …… 即各种类型的循环都可以作为外层循环,也可以作为内层循环。 当程序遇到嵌套循环时,如果外层循环的循环条件允许,则开始执行外层循环的循环体,而内层循环将被外层循环的循环体来执行——只是

  • 对Java来说很新鲜,我在大学的一个入门班做一个项目。我正在尝试做一个方法,在String数组中搜索输入的状态并返回索引。如果用户输入不在数组中的查询,我希望它要求一个新的状态来搜索。我的例外是说“变量statePotion可能尚未初始化。”下面是代码。 提前谢谢!

  • 我对确定上述代码的BigO有点困惑。如果在最外层的循环中,则为(int x=1;x 然而,考虑到最外层循环迭代n 2次,这会改变bigO还是加法常数无关紧要的规则?最后,如果最内层循环迭代n 2次而不是n,会改变什么吗? 非常感谢。

  • 我有一个嵌套的for循环,但是它会减慢一点处理速度,我如何才能使嵌套循环高效。我需要的是对于外循环的每个值,内循环继续其所有迭代。但是,我不认为它会像两个嵌套循环那样影响计算。我的第二个问题是,循环会影响速度还是会支持我的现象? 我的代码:

  • 问题内容: 我正在尝试使用嵌套的for循环显示一个星号菱形。 到目前为止,这是我的代码: 这很接近,但是我要两次打印9个星号。 如何调整第二个for循环以7个星号和2个空格开始输出? 谢谢您的帮助! 问题答案: 在您的第一个for循环中,删除=标记,然后使用<例如 完整代码

  • 我在下面的代码中使用了嵌套的for循环,并且我有一些条件来中断内部的for循环,这提高了代码的性能。 现在,如何使用 Java 8 流来执行相同的逻辑?我想出了下面的代码: 在这里,我不能在java流中使用< code>break语句,所以我使用了< code>return语句,但它仍然运行内部循环,因为它不会中断内部循环,所以性能没有提高。