在OrientDB中，如何获取所有顶点为JSON并排除结果中的边

Question

TRAVERSE vs fetchPlan

I've got a graph (my example is a balanced tree) where I want to generate a JSON structure representing the tree.

Here's how I generate my database for testing:

I have two files, one for the schema and one for data. Here's the FetchPlanTestingCreateSchema.sql file contents:

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;

Here is the FetchPlanTestingData.sql. For brevity, I'm showing 3 levels being created (01, 02, and 03), in my testing though, I've got all 9 levels populated so I can test various $depth settings:

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');

I create the DB/Schema by passing running /opt/orientdb-community/bin/console.sh 'cat FetchPlanTestingCreateSchema.sql FetchPlanTestingData.sql'

Using TRAVERSE, I get a "flat" list of records and it excludes any of the belongsTo edges:

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).

Yay! I can get traverse the records. However, with that result, I'd have to build my nested JSON manually. Seems to defeat the purpose of using a Graph DB Engine.

Using a fetchPlan, I'm getting closer, but still not quite what I want.

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).

That gives me EVERYTHING in the tree. Here's my remaining questions. 1. How do I limit to something like $depth<=2 ?

2. How do I eliminate the in/out/in_belongsTo/out_belongsTo from the result?

3. Can I use a different approach and only include certain classes?

Here's that JSON in a more readable format using fetchplan:*:5 instead of `fetchplan:*:-1':

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"
}

I'd really like to get the nested structure (say level 1 and 2) and have the resulting JSON look like this:

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

Even better would be this type of structure:

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

Essentially, JSON where the class is the key and then there's a nested structure for each class which is connected and don't include any in/out edge information.

Answer 1

For first part of your question , you can get the $depth value from traversal query and write logic to form a tree from the depth

For second part ,

1. If you want to load tree by depth then the value of depth can be specified by giving input like [0-2] , -1 will load entire tree recursively

2.You can skip in edges by adding [ * ]in_*:-2 to the fecth plan but out will be there

Example :

select @this.toJSON("fetchPlan:[ * ]in_ :-2 out_ :-1 ") FROM rid