Labs 3 and 4

Author: Paula Gearon

labs/lab2/src/lab2/asami.clj

@@ -24,9 +24,9 @@
 
 
 (comment
-  (def triples (a/read-triples "../../graphs/starwars.edn"))
-  (def conn (a/create-db))
-  (def tx (a/insert-triples conn triples))
+  (def triples (read-triples "../../graphs/starwars.edn"))
+  (def conn (create-db))
+  (def tx (insert-triples conn triples))
   (d/q '[:find ?name :where [:yoda :name ?name]] conn)
   (d/q '[:find ?character ?name :where [?character :name ?name]] conn)
   (d/q '[:find ?character ?name :where [?character :color "#000000"][?character :name ?name]] conn)

labs/lab2/src/lab2/datascript.clj

@@ -27,8 +27,8 @@
 
 
 (comment
-  (def triples (ds/read-triples "../../graphs/starwars.edn"))
-  (def conn (ds/insert-triples (ds/create-db) triples))
+  (def triples (read-triples "../../graphs/starwars.edn"))
+  (def conn (insert-triples (create-db) triples))
   (d/q '[:find ?name :where [:yoda :name ?name]] @conn)
   (d/q '[:find ?character ?name :where [?character :name ?name]] @conn)
   (d/q '[:find ?character ?name :where [?character :color "#000000"][?character :name ?name]] @conn)

labs/lab3/deps.edn

@@ -1,5 +1,3 @@
 {:paths ["src" "resources"]
- :deps {org.clojure/clojure {:mvn/version "1.11.2"}
-         }
- }
+ :deps {org.clojure/clojure {:mvn/version "1.11.2"} } }
 

labs/lab3/src/lab3/flat.clj

@@ -0,0 +1,11 @@
+(ns lab3.flat
+  (:require [clojure.edn :as edn]))
+
+(defn load-data
+  [filename]
+  (edn/read-string (slurp filename)))
+
+
+(comment
+  (def data (load-data "../../graphs/starwars.edn"))
+)

labs/lab3/src/lab3/indexed.clj

@@ -1,47 +1,38 @@
-(ns lab3.match
-  (:require [clojure.edn :as edn]))
+(ns lab3.indexed
+  (:require [clojure.edn :as edn]
+            [clojure.string :as str]))
 
 (defn add-to-index
-  [index triple]
-  (assoc-in index triple triple))
+  [index [_ _ c :as triple]]
+  (assoc-in index triple c))
 
 (defprotocol Index
   (add [this triple])
-  (match [this pattern])
-  (bind [this pattern]))
+  (match [this pattern]))
 
 (defrecord IndexedGraph [spo pos osp]
+  Index
   (add [this [s p o :as triple]]
     (IndexedGraph. (add-to-index spo triple)
                    (add-to-index pos [p o s])
-                   (add-to-index osp [o s p])))
-  )
+                   (add-to-index osp [o s p]))))
 
 (defn load-data
   [filename]
   (let [data (edn/read-string (slurp filename))]
     (reduce add (IndexedGraph. {} {} {}) data)))
 
-(defn variable?
-  [x]
-  (and (symbol? x) (= \? (first (name x)))))
 
-;; TODO
-
-(defn match
-  [data pattern]
-  )
+(comment
+  ;; Add statements to an SPO index
+  (def i (assoc-in {} [:yoda :interacts-with :luke] :luke))
+  (assoc-in i [:yoda :interacts-with :obi-wan] :obi-wan)
 
-(defn bind
-  [data pattern]
-  )
+  ;; Add statements to a full index
+  (def fi0 (IndexedGraph. {} {} {}))
+  (def fi1 (add fi0 [:yoda :interacts-with :luke]))
+  (def fi2 (add fi1 [:yoda :interacts-with :obi-wan]))
 
-(comment
+  ;; Load the starwars graph
   (def data (load-data "../../graphs/starwars.edn"))
-  (match data '[?yoda :name "Yoda"])
-  (match data '[?character :color "#000000"])
-  (match data '[:yoda :interacts-with ?character])
-  (bind data '[?yoda :name "Yoda"])
-  (bind data '[?character :color "#000000"])
-  (bind data '[:yoda :interacts-with ?character])
 )

labs/lab3/src/lab3/match.clj

@@ -0,0 +1,3 @@
+{:paths ["src" "resources"]
+ :deps {org.clojure/clojure {:mvn/version "1.11.2"} } }
+

labs/lab3/src/lab3/match2.clj

@@ -0,0 +1,60 @@
+(ns lab4.flat
+  (:require [clojure.edn :as edn]))
+
+(defn load-data
+  [filename]
+  (edn/read-string (slurp filename)))
+
+(defn variable?
+  [x]
+  (and (symbol? x) (= \? (first (name x)))))
+
+(defn element-match
+  [p e]
+  (or (variable? p) (= p e)))
+
+(defn match
+  [data pattern]
+  (filter (fn [triple] (every? #(element-match (nth pattern %) (nth triple %)) (range 3))) data))
+
+(defn bind
+  [data pattern]
+  (let [bindings (match data pattern)]
+    (keep (fn [triple] (reduce (fn [bndg n]
+                                 (let [p (nth pattern n)]
+                                   (if (variable? p)
+                                     ;; map the variable to the value
+                                     (assoc bndg p (nth triple n))
+                                     (if (= p (nth triple n))
+                                       ;; pattern element = triple element
+                                       bndg
+                                       ;; elements not equal: return nil
+                                       (reduced nil)))))
+                               {} (range 3)))
+          data)))
+
+(defn bind2
+  [data pattern]
+  (let [bindings (match data pattern)]
+    (keep (fn [triple] (reduce (fn [bndg n]
+                                 (let [p (nth pattern n)]
+                                  (if (variable? p)
+                                    (conj bndg (nth triple n))
+                                    (if (= p (nth triple n)) bndg (reduced nil)))))
+                               [] (range 3)))
+          data)))
+
+(comment
+  (def data (load-data "../../graphs/starwars.edn"))
+  (match data '[?yoda :name "Yoda"])
+  (match data '[?character :color "#000000"])
+  (match data '[:yoda :interacts-with ?character])
+  (bind data '[?yoda :name "Yoda"])
+  (bind data '[?character :color "#000000"])
+  (bind data '[:yoda :interacts-with ?character])
+
+  (def color-pattern '[?character :color "#000000"])
+  (def vars (vec (filter variable? color-pattern)))
+  (def black-characters (bind2 data color-pattern))
+  (map #(zipmap vars %) black-characters)
+)

labs/lab4/deps.edn

@@ -0,0 +1,96 @@
+(ns lab4.indexed
+  (:require [clojure.edn :as edn]
+            [clojure.string :as str]))
+
+(defn variable? [x] (and (symbol? x) (= \? (first (name x)))))
+
+(def ? '?)
+(def x 'x)
+
+(defn normalize [_ pattern] (mapv #(if (variable? %) ? x) pattern))
+
+(defmulti get-from-index normalize)
+(defmethod get-from-index [x x x] [{idx :spo} [s p o]] (let [os (get-in idx [s p])] (if (get os o) [[]] [])))
+(defmethod get-from-index [x x ?] [{idx :spo} [s p o]] (map vector (keys (get-in idx [s p]))))
+(defmethod get-from-index [x ? x] [{idx :osp} [s p o]] (map vector (keys (get-in idx [o s]))))
+(defmethod get-from-index [x ? ?] [{idx :spo} [s p o]] (let [edx (idx s)] (for [[p om] edx o (keys om)] [p o])))
+(defmethod get-from-index [? x x] [{idx :pos} [s p o]] (map vector (keys (get-in idx [p o]))))
+(defmethod get-from-index [? x ?] [{idx :pos} [s p o]] (let [edx (idx p)] (for [[o sm] edx s (keys sm)] [s o])))
+(defmethod get-from-index [? ? x] [{idx :osp} [s p o]] (let [edx (idx o)] (for [[s pm] edx p (keys pm)] [s p])))
+(defmethod get-from-index [? ? ?] [{idx :spo} [s p o]] (for [[s pom] idx [p om] pom o (keys om)] [s p o]))
+
+(defn add-to-index
+  [index [_ _ c :as triple]]
+  (assoc-in index triple c))
+
+(defprotocol Index
+  (add [this triple])
+  (match [this pattern]))
+
+(defrecord IndexedGraph [spo pos osp]
+  Index
+  (add [this [s p o :as triple]]
+    (IndexedGraph. (add-to-index spo triple)
+                   (add-to-index pos [p o s])
+                   (add-to-index osp [o s p])))
+  (match [this pattern]
+    {:vars (vec (filter variable? pattern))
+     :bindings (get-from-index this pattern)}))
+
+(defn load-data
+  [filename]
+  (let [data (edn/read-string (slurp filename))]
+    (reduce add (IndexedGraph. {} {} {}) data)))
+
+(defn export-data
+  [filename data]
+  (let [triples (:bindings (match data '[?s ?p ?o]))]
+    (spit filename (pr-str (vec triples)))))
+
+(defn do-filter
+  [match-result filter-expr]
+  (let [vars (:vars match-result)
+        data (:bindings match-result)
+        fltr (first filter-expr)
+        filter-fn (eval `(fn [~vars] ~fltr))]
+    {:vars vars
+     :bindings (filter filter-fn data)}))
+
+
+(comment
+  ;; Load the starwars graph
+  (def data (load-data "../../graphs/starwars.edn"))
+
+  ;; raw access to the indexes
+  (get-in (:spo data) [:yoda :name])
+  (get (:osp data) "#191970")
+  (let [idx (get (:osp data) "#191970")]
+    (for [[s pm] idx p (keys pm)] [s p]))
+
+  ;; set up variables and patterns
+  (def name-pattern '[?character :name ?name])
+  (def vars (vec (filter variable? name-pattern)))
+  (def template (normalize nil name-pattern))
+
+  ;; select statements from the graph
+  (match data '[?yoda :name "Yoda"])
+  (match data '[?character :color "#000000"])
+  ;; demonstrate that we can still create the bindings maps
+  (def rabe (match data '[:rabe ?attribute ?value]))
+  (map #(zipmap (:vars rabe) %) (:bindings rabe))
+
+  ;; demonstrate filtering results
+  (def names (match data '[?character :name ?name]))
+  (filter (fn [[?character ?name]] (str/starts-with? ?name "Darth")) (:bindings names))
+
+  ;; manually build a filter function
+  (def fltr '(str/starts-with? ?name "Darth"))
+  (def vars (:vars names))
+  (def filter-fn (eval `(fn [~vars] ~fltr)))
+  (filter filter-fn (:bindings names))
+
+  ;; Execute a match and filter in one go
+  (-> data
+      (match '[?character :name ?name])
+      (do-filter '[(str/starts-with? ?name "Darth")]))
+)