# EdgeTriplet Class

An edge triplet represents an edge along with the vertex attributes of its neighboring vertices.

VD: the type of the vertex attribute.

ED: the type of the edge attribute

instance constructor:

new EdgeTriplet()

```
var attr: ED
The attribute associated with the edge

var dstAttr: VD
The destination vertex attribute

var dstId: VertexId
The vertex id of the target vertex

def otherVertexAttr(vid: VertexId): VD
Given one vertex in the edge return the other vertex.

def otherVertexId(vid: VertexId): VertexId
Given one vertex in the edge return the other vertex.

def relativeDirection(vid: VertexId): EdgeDirection
Return the relative direction of the edge to the corresponding vertex.

var srcAttr: VD
The source vertex attribute

var srcId: VertexId
The vertex id of the source vertex

def toString(): String
def
toTuple: ((VertexId, VD), (VertexId, VD), ED)

def vertexAttr(vid: VertexId): VD
Get the vertex object for the given vertex in the edge

```

Example:

```
import org.apache.spark._
import org.apache.spark.graphx._
import org.apache.spark.rdd.RDD

// Create an RDD for the vertices
val users: RDD[(VertexId, (String, String))] =
  sc.parallelize(Array((3L, ("rxin", "student")), (7L, ("jgonzal", "postdoc")),
                       (5L, ("franklin", "prof")), (2L, ("istoica", "prof")),
                       (4L, ("peter", "student"))))
// Create an RDD for edges
val relationships: RDD[Edge[String]] =
  sc.parallelize(Array(Edge(3L, 7L, "collab"),    Edge(5L, 3L, "advisor"),
                       Edge(2L, 5L, "colleague"), Edge(5L, 7L, "pi"),
                       Edge(4L, 0L, "student"),   Edge(5L, 0L, "colleague")))
// Define a default user in case there are relationship with missing user
val defaultUser = ("John Doe", "Missing")

graph.triplets.getClass
/*
res233: Class[_ <: org.apache.spark.rdd.RDD[org.apache.spark.graphx.EdgeTriplet[(String, String),String]]] = class org.apache.spark.rdd.MapPartitionsRDD
graph.triplets is an instance of EdgeTriplet

*/

// Build the initial Graph
val facts: RDD[String] =
  graph.triplets.map((triplet =>
    triplet.srcAttr._1 + " is the " + triplet.attr + " of " + triplet.dstAttr._1))
facts.collect.foreach(println(_))
```

Reference:

<https://github.com/apache/spark/blob/v2.4.5/graphx/src/main/scala/org/apache/spark/graphx/EdgeTriplet.scala>


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://george-jen.gitbook.io/data-science-and-apache-spark/edgetriplet-class.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.