outer-join.clj

(ns cdl.core
  (:refer-clojure :exclude [==])
  (:use [clojure.core.logic][clojure.core.logic.pldb]))


;; Some outer join examples with mini-kanren
;; this is not relational, it use nafc.

;; but nafc is IMHO way better than conda, you can still reorder goals, so it stays simple.

(db-rel men m)
(db-rel robot m)
(db-rel language l d)

(def mydb (db
              [men 'Michel]
              [men 'Joe]
              [men 'Martin]
              [robot 'Borg]
              [language 'Martin 'Scala]
              [language 'Martin 'Java]
              [language 'Joe 'Erlang]
              [language 'Joe 'Prolog]
              [language 'Borg 'Zorg]))





;; outer is the union of inner, left and right. 
(with-db mydb
  (run* [e men? lang]
        (conde
         [          (language e lang)             (men e)(== men? true)] ;; inner
         [          (language e lang)             (nafc men e)(== men? false)] ;; left
         [(nafc #(fresh [l] (language % l)) e)    (men e)(== men? true)]))) ;; right

;;

'([Martin true Scala] [Michel true _0] [Martin true Java] [Borg false Zorg] [Joe true Prolog] [Joe true Erlang])

;; more SQL-ish concerning variables
(with-db mydb
  (run* [e men? lang]      
        (fresh [m l]
               (!= e nil)       
               (conde 
                [(== m e)(== m l)]
                [(== l e)(== m nil)]
                [(== m e)(== l nil)]) 
               (conde 
                [(language l lang)] 
                [(== l nil)(nafc #(fresh [x] (language % x)) m)])
               (conde 
                [(men m)(== men? true)]
                [(== m nil)(nafc men l)(== men? false)]))))

;;
'([Martin true Scala] [Martin true Java] [Joe true Prolog] [Joe true Erlang] [Michel true _0] [Borg false Zorg])