使用 SQL++ 查询过滤多个嵌套数组

Question

在我的存储桶中，文档具有以下结构

{
    "version" : 1,
    "root1" : "root1",
    "root2" : "root2",
    "i" : [
        {
            "i1" : "i1",
            "i2" : "i2",
            "p" : [
                {
                    "id" : 1,
                    "p2" : "p2",
                    "tr" : [
                        {
                            "id" : 1,
                            "x" : "VALID",
                            "check" : false
                        },
                        {
                            "id" : 2,
                            "x" : "INVALID",
                            "check" : false
                        }
                    ]

                },
                {
                    "id" : 2,
                    "p2" : "p2",
                    "tr" : [
                        {
                            "id" : 1,
                            "x" : "VALID",
                            "check" : true
                        },
                        {
                            "id" : 2,
                            "x" : "INVALID",
                            "check" : true
                        }
                    ]

                }
            ]
        }
    ]

}

i

是一个包含字段

p

的数组，它也是一个数组，并且还包含另一个数组字段

tr

我想返回所有具有

tr.x = "VALID"

和

check = false

的文档，并从中删除

tr

，这与此标准无关。 所以对于最后一个例子，返回应该是

{
    "version" : 1,
    "root1" : "root1",
    "root2" : "root2",
    "i" : [
        {
            "i1" : "i1",
            "i2" : "i2",
            "p" : [
                {
                    "id" : 1,
                    "p2" : "p2",
                    "tr" : [
                        {
                            "id" : 1,
                            "x" : "VALID",
                            "check" : false
                        }
                    ]

                }
            ]
        }
    ]
}

Answer 1

选择：

SELECT *
FROM default
WHERE ANY a IN i
      SATISFIES
        ANY b IN a.p 
        SATISFIES
            ANY c IN b.tr 
            SATISFIES 
                c.x = 'VALID' AND c.check = false
            END
        END
      END

这只是嵌套每个嵌套数组的条件，直到可以过滤各个字段。

仅返回匹配数组数据的方法是应用类似的逻辑：

SELECT OBJECT_PUT(default
                 ,"i"
                 ,ARRAY OBJECT_PUT(ii
                                  ,"p"
                                  ,ARRAY OBJECT_PUT(ppp
                                                   ,"tr"
                                                   ,ARRAY tttt 
                                                    FOR tttt IN ppp.tr 
                                                    WHEN
                                                        tttt.x = 'VALID' AND tttt.check = false 
                                                    END
                                                   )
                                   FOR ppp IN ii.p 
                                   WHEN
                                     ANY ttt IN ppp.tr
                                     SATISFIES
                                        ttt.x = 'VALID' AND ttt.check = false
                                     END 
                                   END
                                  ) 
                  FOR ii IN default.i 
                  WHEN 
                    ANY pp IN ii.p 
                    SATISFIES 
                        ANY tt IN pp.tr
                        SATISFIES 
                            tt.x = 'VALID' AND tt.check = false 
                        END
                    END
                  END
                 )
FROM default
WHERE ANY a IN i
      SATISFIES
        ANY b IN a.p 
        SATISFIES
            ANY c IN b.tr 
            SATISFIES 
                c.x = 'VALID' AND c.check = false
            END
        END
      END

它只是用每个嵌套级别的过滤元素替换（OBJECT_PUT 函数）元素。由于在应用 OBJECT_PUT 之前对元素进行过滤，因此在每个级别都会重复相同的元素选择。

毫无疑问还有其他方法。

HTH.