在orientdb遍歷中使用maxdepth和while

Question

我正在使用orientdb v2.1.4 是否有可能在SQL或Java API中使用while條件和maxdepth參數從目標記錄執行orientdb遍歷？例如：

traverse all() from TargetRecordID maxdepth 25 while @class <> 'some_edge_class' 

orientdb分析器似乎應用maxdepth條件並忽略while條件。

我使用while條件，因爲我總體上有10個不同的邊緣類，但我希望做遍歷，同時排除邊緣類的子集（〜3）。如果您在遍歷期間使用了另一種方法來忽略某些邊緣類，那也會很好。

Answer 1

嘗試此查詢：

traverse both() from YourClass while both('your_edge_class').size() = 0 and $depth <= 25 

所以導線不會將連接到邊緣頂點/你指定的邊緣

編輯：

考慮下面的圖形示例，假設您不希望邊緣type1和type2，您想要將節點1,2,3,4,5和8連接到邊緣type 3還是要避免所有頂點也連接到type 1和type 2？

編輯：

您可以使用此javascript函數有三個參數（RID，MAXDEPTH，excludeEdges）

var g=orient.getGraph(); 
var result=[]; 
var current=[]; 
var next=[]; 
var listEdges=excludeEdges.substring(1,excludeEdges.length-1).split(","); 
var root=g.command('sql','select from '+rid); 
current.push(root[0]); 
var step=1; 
while(current.length>0 && step<=maxDepth){ 
    for(i=0;i<current.length;i++){ 
     getVertex(current[i],"OUT"); 
     getVertex(current[i],"IN"); 
    } 
    change(); 
    step++; 
} 
return result; 

function change(){ 
    current=[]; 
    for (index=0;index<next.length;index++) 
     current.push(next[index]); 
    next=[]; 
} 

function getVertex(start,direction){ 
    var edgeDir="outE()"; 
    var reverseDirection="in"; 
    if(direction=="IN"){ 
     edgeDir="inE()"; 
     reverseDirection="out"; 
    } 
    var edges=g.command("sql","select expand("+edgeDir +") from "+start.getId()); 
    for(h=0;h<edges.length;h++){ 
     var found=false; 
     for(m=0;m<listEdges.length;m++){ 
      if(edges[h].getProperty("@class")==listEdges[m]){ 
       found=true; 
       break; 
      } 
     } 
     if(found==false){ 
      var vertex=g.command("sql","select expand("+ reverseDirection + ") from " +edges[h].getId()); 
      for(j=0;j<result.length;j++){ 
       if(result[j].getId().toString().equals(vertex[0].getId().toString()) || 
        vertex[0].getId().toString().equals(rid)){ 
        found=true; 
        break; 
       } 
      } 
      if(found==false){ 
       result.push(vertex[0]); 
       next.push(vertex[0]); 
      } 
     } 
    } 
} 

使用以下命令

select expand(result) from (select myFunction("#9:1",25,"[type1,type2]") as result) 

Answer 2

隨着Java Api

OrientGraph g=new OrientGraph("remote:localhost/yourDb"); 
Traverse traverse = new Traverse(g); 

List<String> listExcludeEdges=new ArrayList<String>(); 
listExcludeEdges.add("type1"); 
listExcludeEdges.add("type2"); 
int maxDepth=3; 
String id="#9:1"; 

Set<Vertex> vertex=traverse.get(id,maxDepth,listExcludeEdges); 
for(Vertex v:vertex){ 
    System.out.println(v.getId()); 
} 
g.shutdown(); 

類遍歷

import java.util.LinkedHashSet; 
import java.util.List; 
import java.util.Set; 
import java.util.regex.Matcher; 
import java.util.regex.Pattern; 

import com.tinkerpop.blueprints.Direction; 
import com.tinkerpop.blueprints.Edge; 
import com.tinkerpop.blueprints.Vertex; 
import com.tinkerpop.blueprints.impls.orient.OrientGraph; 

public class Traverse { 

    private Set<Vertex> listVertex = new LinkedHashSet<Vertex>(); 
    private OrientGraph g; 
    private int maxDepth; 
    private List<String> listExcludeEdges; 
    private Vertex root; 

    public Traverse(OrientGraph g) { 
     this.g = g; 
    } 

    public Set<Vertex> get(String id,int maxDepth,List<String> listExcludeEdges) { 
     this.maxDepth=maxDepth; 
     this.listExcludeEdges=listExcludeEdges; 
     if(checkClassOrRid(id)){ 
      if (getRoot(id)) 
       getChildren(1,this.root); 
     } 
     return this.listVertex; 
    } 

    private boolean checkClassOrRid(String id){ 
     Pattern pattern = Pattern.compile("^#[0-9]+:[0-9]+"); 
     Matcher matcher = pattern.matcher(id); 
     if (matcher.matches()) { 
      for (Vertex v : g.getVertices()) { 
       if (v.getId().toString().equals(id)) 
        return true; 
      } 
     } 
     return false; 
    } 

    protected boolean getRoot(String id) {  
     this.root = g.getVertex(id); 
     if(this.root!=null) 
      return true; 
     return false; 
    } 

    protected void getChildren(int step,Vertex from) { 
     if(step<=maxDepth){ 
      getVertex(Direction.OUT,from,step); 
      getVertex(Direction.IN,from,step); 
     } 
    } 

    private void getVertex(Direction direction,Vertex from,int step){ 
     Iterable<Edge> edges = from.getEdges(direction); 
     for(Edge e:edges){ 
      boolean found=false; 
      for(String s:this.listExcludeEdges){ 
       if(e.getProperty("@class").equals(s)) 
        found=true; 
      } 
      if(found==false){ 
       Vertex vertex=null; 
       if(direction==Direction.OUT) 
        vertex=e.getVertex(Direction.IN); 
       else 
        vertex=e.getVertex(Direction.OUT); 
       this.listVertex.add(vertex); 
       getChildren(step+1,vertex); 
      } 
     } 
    } 
}