[JAVA] Le monde de Clara-Rules (3)

Dernière fois

J'ai appris de la vidéo de la conférence que les règles de clara peuvent être utilisées pour des opérations de jointure entre différentes entités, j'ai donc implémenté moi-même un exemple simple.

problème

• TypeA --Dispose des attributs attr-a et join-key
• TypeB --Dispose des attributs attr-b et join-key
• TypeC --Avec TypeA.attr-a et TypeB.attr-b avec une clé de jointure commune comme attributs

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}

• Le type C est imprimé pour les paires de type A et de type B qui ont une clé commune : join-key comme prévu. Tu l'as fait! --(-> TypeB "b4": qux)n'apparaît pas dans le résultat car il n'y a pas de fait TypeA avec le même: join-key: qux. Je vois.

Explication de «<-» sur le côté gauche de «défrule»

Liez le fait lui-même à une variable et non à l'attribut du fait. En prenant [? Result <-TypeC] comme exemple, la totalité de l'instance TypeC correspondante est liée à? Result.

Impressions

• La logique de jointure en mémoire peut être écrite de manière déclarative avec une approche différente de SQL
• Par exemple, si l'opération de jointure sur la base de données est le goulot d'étranglement de l'évolutivité horizontale, elle peut être utilisée pour modifier l'opération de jointure à effectuer en mémoire par l'application.
• Ou cela peut être utile dans un environnement où vous avez des données mais ne pouvez pas les interroger.

Suite