[JAVA] Die Welt der Clara-Regeln (3)

Letztes Mal

Aus dem Video der Vorlesung habe ich gelernt, dass Clara-Regeln für Verknüpfungsoperationen zwischen verschiedenen Entitäten verwendet werden können. Deshalb habe ich selbst ein einfaches Beispiel implementiert.

Problem

• TypeA
• Hat Attribute attr-a und Join-Key
• TypeB
• Hat Attribute attr-b und Join-Key
• TypeC
• Hat TypeA.attr-a und TypeB.attr-b mit einem gemeinsamen Join-Schlüssel als Attribute

Code

(ns  clara-rules.join
  (:require [clara.rules :refer [defrule fire-rules insert insert! mk-session]]))

(defrecord TypeA [attr-a join-key])

(defrecord TypeB [attr-b join-key])

(defrecord TypeC [attr-a attr-b join-key])

(defrule Join
  [TypeA (= ?jk-a join-key) (= ?a attr-a)]
  [TypeB (= join-key ?jk-a) (= ?b attr-b)]
  =>
  (insert! (->TypeC ?a ?b ?jk-a)))

(defrule Print
  [?result <- TypeC];; Will always match
  =>
  (println ?result))

(-> (mk-session)
    (insert (->TypeA "a1" :foo)
            (->TypeA "a2" :bar)
            (->TypeA "a3" :baz)
            (->TypeB "b1" :foo)
            (->TypeB "b2" :bar)
            (->TypeB "b3" :baz)
            (->TypeB "b4" :qux))
    (fire-rules))
;;#clara_rules.join.TypeC{:attr-a a1, :attr-b b1, :join-key :foo}
;;#clara_rules.join.TypeC{:attr-a a2, :attr-b b2, :join-key :bar}
;;#clara_rules.join.TypeC{:attr-a a3, :attr-b b3, :join-key :baz}

--Typ C wird für Paare vom Typ A und Typ B gedruckt, die wie vorgesehen einen gemeinsamen : Join-Schlüssel haben. Du hast es geschafft! --(-> TypeB "b4": qux)erscheint nicht im Ergebnis, da es keine TypeA-Tatsache mit demselben: join-key: qux gibt. Das war's.

Erklärung von <- auf der linken Seite von defrule

Binden Sie die Tatsache selbst an eine Variable, nicht an das Attribut der Tatsache. Am Beispiel von "[? Ergebnis <-TypeC]" ist die gesamte übereinstimmende TypeC-Instanz an "Ergebnis" gebunden.

Impressionen

• Die speicherinterne Verknüpfungslogik kann deklarativ mit einem anderen Ansatz als SQL geschrieben werden
• Wenn die Verknüpfungsoperation in der Datenbank beispielsweise den Engpass der horizontalen Skalierbarkeit darstellt, kann sie verwendet werden, um die von der Anwendung im Speicher auszuführende Verknüpfungsoperation zu ändern.
• Oder es kann in einer Umgebung nützlich sein, in der Sie Daten haben, diese aber nicht abfragen können.

Fortsetzung