在OrientDB中，如何以JSON的形式获得所有眩晕，并在结果中排除边缘

Question

导线vs fetchPlan

我有一个图(我的例子是一个平衡树)，其中我想生成一个表示树的JSON结构。

下面是我如何生成用于测试的数据库：

我有两个文件，一个用于架构，一个用于数据。以下是FetchPlanTestingCreateSchema.sql文件的内容：

SET ignoreErrors true;
DROP DATABASE remote:localhost/FetchPlanTesting admin admin;
SET ignoreErrors false;

CREATE DATABASE remote:localhost/FetchPlanTesting admin admin plocal graph;

CREATE CLASS Level01 extends V;
CREATE CLASS Level02 extends V;
CREATE CLASS Level03 extends V;
CREATE CLASS Level04 extends V;
CREATE CLASS Level05 extends V;
CREATE CLASS Level06 extends V;
CREATE CLASS Level07 extends V;
CREATE CLASS Level08 extends V;
CREATE CLASS Level09 extends V;

CREATE CLASS belongsTo extends E;

这是FetchPlanTestingData.sql。为了简洁起见，我展示了正在创建的3个级别(01、02和03)，但是在我的测试中，我已经填充了所有9个级别，以便测试各种$depth设置：

CREATE VERTEX Level01 SET name = 'Item01_at_Level01';
CREATE VERTEX Level01 SET name = 'Item02_at_Level01';
CREATE VERTEX Level02 SET name = 'Item01_at_Level02';
CREATE EDGE belongsTo FROM (SELECT FROM Level02 WHERE name = 'Item01_at_Level02') TO (SELECT FROM Level01 WHERE name = 'Item02_at_Level01');
CREATE VERTEX Level02 SET name = 'Item02_at_Level02';
CREATE EDGE belongsTo FROM (SELECT FROM Level02 WHERE name = 'Item02_at_Level02') TO (SELECT FROM Level01 WHERE name = 'Item01_at_Level01');
CREATE VERTEX Level02 SET name = 'Item03_at_Level02';
CREATE EDGE belongsTo FROM (SELECT FROM Level02 WHERE name = 'Item03_at_Level02') TO (SELECT FROM Level01 WHERE name = 'Item02_at_Level01');
CREATE VERTEX Level02 SET name = 'Item04_at_Level02';
CREATE EDGE belongsTo FROM (SELECT FROM Level02 WHERE name = 'Item04_at_Level02') TO (SELECT FROM Level01 WHERE name = 'Item01_at_Level01');
CREATE VERTEX Level03 SET name = 'Item01_at_Level03';
CREATE EDGE belongsTo FROM (SELECT FROM Level03 WHERE name = 'Item01_at_Level03') TO (SELECT FROM Level02 WHERE name = 'Item02_at_Level02');
CREATE VERTEX Level03 SET name = 'Item02_at_Level03';
CREATE EDGE belongsTo FROM (SELECT FROM Level03 WHERE name = 'Item02_at_Level03') TO (SELECT FROM Level02 WHERE name = 'Item03_at_Level02');
CREATE VERTEX Level03 SET name = 'Item03_at_Level03';
CREATE EDGE belongsTo FROM (SELECT FROM Level03 WHERE name = 'Item03_at_Level03') TO (SELECT FROM Level02 WHERE name = 'Item04_at_Level02');
CREATE VERTEX Level03 SET name = 'Item04_at_Level03';
CREATE EDGE belongsTo FROM (SELECT FROM Level03 WHERE name = 'Item04_at_Level03') TO (SELECT FROM Level02 WHERE name = 'Item01_at_Level02');
CREATE VERTEX Level03 SET name = 'Item05_at_Level03';
CREATE EDGE belongsTo FROM (SELECT FROM Level03 WHERE name = 'Item05_at_Level03') TO (SELECT FROM Level02 WHERE name = 'Item02_at_Level02');
CREATE VERTEX Level03 SET name = 'Item06_at_Level03';
CREATE EDGE belongsTo FROM (SELECT FROM Level03 WHERE name = 'Item06_at_Level03') TO (SELECT FROM Level02 WHERE name = 'Item03_at_Level02');
CREATE VERTEX Level03 SET name = 'Item07_at_Level03';
CREATE EDGE belongsTo FROM (SELECT FROM Level03 WHERE name = 'Item07_at_Level03') TO (SELECT FROM Level02 WHERE name = 'Item04_at_Level02');
CREATE VERTEX Level03 SET name = 'Item08_at_Level03';
CREATE EDGE belongsTo FROM (SELECT FROM Level03 WHERE name = 'Item08_at_Level03') TO (SELECT FROM Level02 WHERE name = 'Item01_at_Level02');

我通过传递运行/opt/orientdb-community/bin/console.sh 'cat FetchPlanTestingCreateSchema.sql FetchPlanTestingData.sql'来创建DB/Schema

通过遍历，我得到了一个记录的“平面”列表，它排除了任何belongsTo边：

SELECT * FROM (TRAVERSE * FROM (SELECT FROM Level01 WHERE name = 'Item01_at_Level01') WHILE $depth<=2) WHERE @class <> 'belongsTo' LIMIT 1000

orientdb {db=FetchPlanTesting}> SELECT * FROM (TRAVERSE * FROM (SELECT FROM Level01 WHERE name = 'Item01_at_Level01') WHILE $depth<=2) WHERE @class <> 'belongsTo' LIMIT 1000

----+-----+-------+-----------------+------------+-------------
#   |@RID |@CLASS |name             |in_belongsTo|out_belongsTo
----+-----+-------+-----------------+------------+-------------
0   |#11:0|Level01|Item01_at_Level01|[size=2]    |null
1   |#12:1|Level02|Item02_at_Level02|[size=2]    |[size=1]
2   |#12:3|Level02|Item04_at_Level02|[size=2]    |[size=1]
----+-----+-------+-----------------+------------+-------------

3 item(s) found. Query executed in 0.006 sec(s).

耶！我可以查一下记录。但是，有了这个结果，我必须手动构建嵌套的JSON。似乎没有达到使用图形数据库引擎的目的。

使用fetchPlan，我越来越接近了，但仍然不是我想要的。

orientdb {db=FetchPlanTesting}> SELECT @this.toJSON('fetchPlan:*:-1') FROM (SELECT FROM Level01 WHERE name = 'Item01_at_Level01')

----+------+----------------------------------------------------------------------------------------------------------------------------------
#   |@CLASS|this
----+------+----------------------------------------------------------------------------------------------------------------------------------
0   |null  |{"name":"Item01_at_Level01","in_belongsTo":[{"out":{"name":"Item02_at_Level02","in_belongsTo":[{"out":{"name":"Item01_at_Level0...
----+------+----------------------------------------------------------------------------------------------------------------------------------

1 item(s) found. Query executed in 0.112 sec(s).

这给了我树上的一切。这是我剩下的问题。1.如何限制像$depth<=2这样的东西

1. 如何从结果中消除入/出/入_归属/出_归属？
2. 我可以使用不同的方法并且只包括某些类吗？

以下是使用fetchplan:*:5而不是“`fetchplan：*：-1”的更具可读性的JSON：

SELECT @this.toJSON('fetchPlan:*:5') FROM (SELECT FROM Level01 WHERE name = 'Item01_at_Level01')
{
  "in_belongsTo": [
    {
      "in": "#11:0", 
      "out": {
        "in_belongsTo": [
          {
            "in": "#12:1", 
            "out": {
              "in_belongsTo": [
                {
                  "in": "#13:0", 
                  "out": "#14:7"
                }, 
                {
                  "in": "#13:0", 
                  "out": "#14:15"
                }
              ], 
              "name": "Item01_at_Level03", 
              "out_belongsTo": [
                "#20:4"
              ]
            }
          }, 
          {
            "in": "#12:1", 
            "out": {
              "in_belongsTo": [
                {
                  "in": "#13:4", 
                  "out": "#14:3"
                }, 
                {
                  "in": "#13:4", 
                  "out": "#14:11"
                }
              ], 
              "name": "Item05_at_Level03", 
              "out_belongsTo": [
                "#20:8"
              ]
            }
          }
        ], 
        "name": "Item02_at_Level02", 
        "out_belongsTo": [
          "#20:1"
        ]
      }
    }, 
    {
      "in": "#11:0", 
      "out": {
        "in_belongsTo": [
          {
            "in": "#12:3", 
            "out": {
              "in_belongsTo": [
                {
                  "in": "#13:2", 
                  "out": "#14:1"
                }, 
                {
                  "in": "#13:2", 
                  "out": "#14:9"
                }
              ], 
              "name": "Item03_at_Level03", 
              "out_belongsTo": [
                "#20:6"
              ]
            }
          }, 
          {
            "in": "#12:3", 
            "out": {
              "in_belongsTo": [
                {
                  "in": "#13:6", 
                  "out": "#14:5"
                }, 
                {
                  "in": "#13:6", 
                  "out": "#14:13"
                }
              ], 
              "name": "Item07_at_Level03", 
              "out_belongsTo": [
                "#20:10"
              ]
            }
          }
        ], 
        "name": "Item04_at_Level02", 
        "out_belongsTo": [
          "#20:3"
        ]
      }
    }
  ], 
  "name": "Item01_at_Level01"
}

我非常希望获得嵌套结构(例如，第1级和第2级)，并使最终的JSON看起来如下所示：

{
  "Level02": [
    {
      "name": "Item02_at_Level02", 
    }, 
    {
      "name": "Item04_at_Level02", }
    }
  ], 
  "name": "Item01_at_Level01"
}

更好的是这种结构：

{
  "Level01": [
    {
      "name": "Item01_at_Level01",
      "Level02": [
        {
          "name": "Item02_at_Level02",
          "Level03": [
            {
              "name": "Item01_at_Level03", 
            },
            {
              "name": "Item05_at_Level03", 
            }
          ]
        },
        {
          "name": "Item04_at_Level02",
          "Level03": [
            {
            },
            {
            }
          ]
        }
      ]
    }
  ]
}

本质上，JSON类是键，然后每个类都有一个嵌套结构，它是连接的，不包含任何输入/输出边缘信息。

Answer 1

对于问题的第一部分，您可以从遍历查询获得$depth值，并从深度上编写逻辑以形成树。

第二部分，

1. 如果您希望按深度加载树，则可以通过提供0-2这样的输入来指定深度值，-1将递归地加载整个树。

2.你可以跳过边缘，将* in_*:-2添加到粪计划中，但结果会出现

例子：

从rid中选择@this.toJSON("fetchPlan：*in_：-2 out__:-1 ")