Additional functions for traversing and property management.

src/neo4j.clj

@@ -15,23 +15,40 @@
                                Traverser
                                Traverser$Order)))
 
+(declare properties)
+
 (def *neo* nil)
 (def *tx* nil)
 
+(defn start
+  [db-path]
+  (alter-var-root #'*neo* (fn [_] (EmbeddedNeo. db-path))))
+
+(defn shutdown
+  []
+  (.shutdown *neo*))
+
 (def both Direction/BOTH)
 (def incoming Direction/INCOMING)
 (def outgoing Direction/OUTGOING)
 
-(def breadth Traverser$Order/BREADTH_FIRST)
-(def depth   Traverser$Order/DEPTH_FIRST)
-
-(def depth-one StopEvaluator/DEPTH_ONE)
+(def breadth-first Traverser$Order/BREADTH_FIRST)
+(def depth-first   Traverser$Order/DEPTH_FIRST)
+
+(defn depth-of 
+  "Return a StopEvaluator for the given traversal depth."
+  [d] 
+  (if (== d 1) 
+    StopEvaluator/DEPTH_ONE
+    (proxy [StopEvaluator] []
+      (isStopNode [#^TraversalPosition pos]
+                  (== (.depth pos) d)))))
 (def end-of-graph StopEvaluator/END_OF_GRAPH)
 
 (def all ReturnableEvaluator/ALL)
 (def all-but-start ReturnableEvaluator/ALL_BUT_START_NODE)
 
-(defmacro with-neo [ #^String fname & body ]
+(defmacro with-neo [#^String fname & body ]
   `(binding [*neo* (new ~EmbeddedNeo ~fname)]
     (try ~@body
       (finally (.shutdown *neo*)))))
@@ -45,6 +62,12 @@
 
 (defn failure [] (.failure *tx*))
 
+(defmacro with-tx [& body]
+  `(tx
+     (let [val# (do ~@body)]
+       (success)
+       val#)))
+
 (defn name-or-str
   [x]
   (if (keyword? x) 
@@ -54,7 +77,7 @@
 (defn new-node 
   ([] (.createNode *neo*))
   ([props] (let [node (new-node)]
-             (set-properties node props)
+             (properties node props)
              node)))
 
 (defn top-node [] (.getReferenceNode *neo*))
@@ -75,26 +98,46 @@
     (isStopNode [#^TraversalPosition p] (f p))))
 
 (defn property
-  [#^PropertyContainer c key]
-  (.getProperty c (name key)))
+  "Necessary?  Maybe remove it in favor of properties."
+  ([#^PropertyContainer c key]
+     (.getProperty c (name key)))
+  ([#^PropertyContainer c key val]
+     (.setProperty c (name-or-str key) val)))
 
 (defn properties 
-  "Return a map of properties."
-  [#^PropertyContainer c]
-  (let [ks (.getPropertyKeys c)]
-    (into {} (map (fn [k] [(keyword k) (.getProperty c k)]) ks))))
-
-(defn set-properties
-  "Set properties of a node or relationship."
-  [#^PropertyContainer c props]
-  (doseq [[k v] props]
-    (.setProperty c (name-or-str k) (or v "")))
-  nil)
+  "Return or set a map of properties."
+  ([#^PropertyContainer c]
+     (let [ks (.getPropertyKeys c)]
+       (into {} (map (fn [k] [(keyword k) (.getProperty c k)]) ks))))
+  ([#^PropertyContainer c props]
+     (doseq [[k v] props]
+       (.setProperty c (name-or-str k) (or v "")))
+     nil))
 
 (defn node-delete 
   "Delete the given node."
   [#^Node n]
   (if-let [rs (.getRelationships n)]
     (doseq [r rs]
       (.delete r)))
-  (.delete n))
+  (.delete n))
+
+(defn traverse
+  "Traverse the graph.  Starting at the given node, traverse the graph
+in either bread-first or depth-first order, stopping when the stop-fn returns
+true.  The filter-fn should return true for any node reached during the traversal
+that is to be returned in the sequence.  The map of relationships and directions
+is used to decide which edges to traverse."
+  [#^Node start-node order stop-evaluator return-evaluator relationship-direction]
+  (.getAllNodes (.traverse start-node 
+                           order
+                           stop-evaluator
+                           return-evaluator
+                           (into-array Object (mapcat identity (map (fn [[k v]] 
+                                                                      [(relationship k) v]) 
+                                                                    relationship-direction))))))
+(defn lookup
+  "Inside a transation, looks up nodes by index key for the given index."
+  [idx & ids]
+  (doall (map (fn [k] (.getSingleNodeFor idx k)) 
+              ids)))