Вложенный поиск «для цикла» в SQL - Azure CosmosDB

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 документов, и я считаю, что мне следует использовать механизм поиска, доступный в самом Космосе. Кто-нибудь может помочь мне понять, какой SQL-запрос сможет выполнять функции такого типа?

Обыскав все, можно ли искать 5 последних документов?

Спасибо за понимание заранее

Answer 1

1. Может ли кто-нибудь помочь мне понять, какой SQL-запрос сможет выполнять этот тип функции?

Привет, JDT. Согласно вашему образцу и описанию, я предлагаю вам использовать ARRAY_CONTAINS в cosmos db sql. Пожалуйста, обратитесь к моему образцу:

образцы документов:

[
    {
        "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, пока не поддерживаются в космосе. Тем не менее, TOP поддерживается Cosmos db. Так что, если вы можете добавить поле сортировки (например, дату или идентификатор), то вы можете использовать sql:

select top 5 from c order by c.sort desc

Надеюсь, это поможет вам.