Sure!
For example, let me give you more details about my structure.
Each user has an "Account" vertex. Each Account vertex is linked to one "Social Profile" vertex. And from that "Social Profile" vertex we have all the edges to the user's friends. Each "Account" is identified by a unique "accountId", which is a STRING (it's actually a UUID string). "accountId" has a UNIQUE_HASH_INDEX.
[Account] --> (1 to 1) --> [Social Profile] --> (1 to many) friends --> [Social Profile]
[Account] --> (1 to 1) --> [Public Profile]
When the page loads, I'm loading the user's Social Profile, and then loading each friend's Public Profile details. Currently this seems to take almost 100ms although my account only has 6 friends!
Here's how I create a connection to the database. First I create a single connection pool:
this.graphFactory = new OrientGraphFactory(
parsedConfig.connString,
parsedConfig.username,
parsedConfig.password)
.setupPool(
parsedConfig.minConnPoolSize,
parsedConfig.maxConnPoolSize);
And then I create a transaction:
this.oTx = this.graphFactory.getTx();
Here's how I get the user's Account vertex:
// Get Account vertex
return (OrientVertex)db.getVertices(
"Account.accountId", accountId)
.iterator().next();
And then I traverse to the linked Social Profile vertex (via edge)
// Get linked Social Profile vertex
return (OrientVertex)accountVtx.getVertices(
Direction.OUT,
EDGE_ACCOUNT_SOCIAL_PROFILE)
.iterator().next();
And finally I get all the friends' account IDs and friendship status.
// Retrieve account IDs of all friends, determine friendship status
for (Direction direction
: new Direction[]{ Direction.IN, Direction.OUT }) {
// Retrieve the iterator for the current direction
Iterator<Edge> friendshipEdgeIterator =
vtx.getEdges(
direction,
EDGE_SOCIAL_PROFILE_FRIENDSHIP)
.iterator();
// For each result...
while (friendshipEdgeIterator.hasNext()) {
Edge friendshipEdge = friendshipEdgeIterator.next();
// Retrieve other social profile vertex
Vertex otherSocialProfileVtx = friendshipEdge.getVertex(
(direction == Direction.IN ?
Direction.OUT : Direction.IN ));
// Retrieve other account vertex
Vertex otherAccountVtx = this.traverseVertex(
otherSocialProfileVtx,
Direction.IN,
OrientDbPersistence.EDGE_ACCOUNT_SOCIAL_PROFILE);
String otherAccountId =
otherAccountVtx.getProperty(PROP_ACCOUNT_ID);
// Is the friendship confirmed?
if (friendshipEdge.getPropertyKeys().contains(PROP_CONFIRMED)
&& (boolean)friendshipEdge.getProperty(PROP_CONFIRMED)) {
// Yes -- confirmed friendship.
socialProfile.getFriendshipMap()
.addConfirmedFriendship(otherAccountId);
}
else {
// No -- pending friendship.
if (direction == Direction.IN) {
// Pending incoming friendship
socialProfile.getFriendshipMap()
.addPendingIncomingFriendship(otherAccountId);
}
else {
// Pending outgoing friendship
socialProfile.getFriendshipMap()
.addPendingOutgoingFriendship(otherAccountId);
}
}
}
}
And finally, once I have all these IDs, I load each friend's public profile.
I get their Account vertex (same way as above, by accountId key), and traverse to their Public Profile vertex.
// Get linked Public Profile vertex
return (OrientVertex)accountVtx.getVertices(
Direction.OUT,
EDGE_ACCOUNT_PUBLIC_PROFILE)
.iterator().next();
Again, this seems to be taking way too long for a few lookups by key and edge traversals. This is compounded by the fact that my website is a single-page application (SPA), so I'm essentially loading all the user's friends and his/her channels in one go. All the 100ms delays add up to many seconds, etc.
Can you find anything wrong with my implementation?