[250426] datascript 코드 읽기

(defrecord Datom [e a v tx added])

;; EAV 순서로 비교하는 비교자 함수 (tx는 내림차순)
(defn datom-eav-comparator [^Datom d1 ^Datom d2]
  (let [e-comp (compare (.e d1) (.e d2))]
    (if (zero? e-comp)
      (let [a-comp (compare (.a d1) (.a d2))]
	(if (zero? a-comp)
	  (let [v-comp (compare (.v d1) (.v d2))]
	    (if (zero? v-comp)
	      ;; E, A, V가 모두 같으면 tx를 내림차순으로 비교하여 최신 datom이 앞에 오도록 함
	      (compare (.tx d2) (.tx d1)) ; Note: tx descending
	      v-comp))
	  a-comp))
      e-comp)))              

; AEV 순서로 비교하는 비교자 함수 (tx는 내림차순)
(defn datom-aev-comparator [^Datom d1 ^Datom d2]
  (let [a-comp (compare (.a d1) (.a d2))]
    (if (zero? a-comp)
      (let [e-comp (compare (.e d1) (.e d2))]
	(if (zero? e-comp)
	  (let [v-comp (compare (.v d1) (.v d2))]
	    (if (zero? v-comp)
	      (compare (.tx d2) (.tx d1)) ; Note: tx descending
	      v-comp))
	  e-comp))
      a-comp)))

; AVE 순서로 비교하는 비교자 함수 (tx는 내림차순)
(defn datom-ave-comparator [^Datom d1 ^Datom d2]
  (let [a-comp (compare (.a d1) (.a d2))]
    (if (zero? a-comp)
      (let [v-comp (compare (.v d1) (.v d2))]
	(if (zero? v-comp)
	  (let [e-comp (compare (.e d1) (.e d2))]
	    (if (zero? e-comp)
	      (compare (.tx d2) (.tx d1)) ; Note: tx descending
	      e-comp))
	  v-comp))
      a-comp)))

; Datom 레코드 정의 시 비교 로직 포함 (선택적)
; Clojure 1.11+ 에서는 defrecord가 Comparable을 구현하므로,
; 별도 비교자만으로도 충분할 수 있음.
; 필요 시 -compare 메서드를 구현하여 eav 기준 비교 로직 추가 가능.
(defrecord Datom [e a v tx added]
  Comparable ; Clojure 1.11+
  (compareTo [this other]
    (datom-eav-comparator this other))) ; 기본 비교 순서를 EAVT로 설정

(defn empty-db
  ( (empty-db {}))
  ([schema]
   (map->DB {:schema schema
	     :eavt   (sorted-set-by datom-eav-comparator)
	     :aevt   (sorted-set-by datom-aev-comparator)
	     :avet   (sorted-set-by datom-ave-comparator)
	     :max-tx 0
	     :max-eid 0})))

(ns simple-datascript.core
  (:require [clojure.set :as set])
  (:import [clojure.lang PersistentQueue]))

;; --- Data Structures ---

;; Datom: The basic unit of information [e a v tx added]
;; Implements Comparable for default EAVT sorting (tx descending for latest)
(defrecord Datom [e a v ^long tx ^boolean added]
  Comparable
  (compareTo [this other]
    (let [^Datom o other
	  e-cmp (compare (.e this) (.e o))]
      (if (not= 0 e-cmp) e-cmp
	  (let [a-cmp (compare (.a this) (.a o))]
	    (if (not= 0 a-cmp) a-cmp
		(let [v-cmp (compare (.v this) (.v o))]
		  (if (not= 0 v-cmp) v-cmp
		      ;; Tx descending: latest tx comes first for same EAV
		      (compare (.tx o) (.tx this)))))))))))

;; Comparators for other index orders
(defn datom-aevt-comparator [^Datom d1 ^Datom d2]
  (let [a-cmp (compare (.a d1) (.a d2))]
    (if (not= 0 a-cmp) a-cmp
	(let [e-cmp (compare (.e d1) (.e o))]
	  (if (not= 0 e-cmp) e-cmp
	      (let [v-cmp (compare (.v d1) (.v o))]
		(if (not= 0 v-cmp) v-cmp
		    (compare (.tx o) (.tx this)))))))))

(defn datom-avet-comparator [^Datom d1 ^Datom d2]
  (let [a-cmp (compare (.a d1) (.a d2))]
    (if (not= 0 a-cmp) a-cmp
	(let [v-cmp (compare (.v d1) (.v o))]
	  (if (not= 0 v-cmp) v-cmp
	      (let [e-cmp (compare (.e d1) (.e o))]
		(if (not= 0 e-cmp) e-cmp
		    (compare (.tx o) (.tx this)))))))))

;; Database: Immutable snapshot containing schema and indexes
(defrecord DB [schema eavt aevt avet ^long max-tx ^long max-eid]
  ;; Implement ILookup for easy access to indexes? (optional)
  )

;; Transaction Report: Result of a transaction
(defrecord TxReport [db-before db-after tx-data tempids])

;; --- Core Functions ---

(defn empty-db
  "Creates an empty database value, optionally with a schema."
  ( (empty-db {}))
  ([schema]
   (map->DB {:schema schema
	     :eavt   (sorted-set-by datom-eav-comparator)
	     :aevt   (sorted-set-by datom-aev-comparator)
	     :avet   (sorted-set-by datom-ave-comparator)
	     :max-tx 0
	     :max-eid 0})))

(defn- next-eid [max-eid-atom]
  (swap! max-eid-atom inc))

(defn- resolve-tempid [tempids-atom max-eid-atom eid]
  "Resolves a tempid (negative integer) to a new entity ID."
  (if (and (integer? eid) (neg? eid))
    (or (get @tempids-atom eid)
	(let [new-eid (next-eid max-eid-atom)]
	  (swap! tempids-atom assoc eid new-eid)
	  new-eid))
    eid))

(defn- datoms-internal
  "Internal helper for datoms lookup using subseq."

  (let [index-set (get db index)
	comparator (condp = index
		     :eavt datom-eav-comparator
		     :aevt datom-aevt-comparator
		     :avet datom-avet-comparator)]
    (if (empty? components)
      (seq index-set)
      (let [;; Create lower bound datom for subseq
	    ;; Use a special marker or nil for unspecified components
	    ;; Comparator needs to handle these markers correctly (e.g., nil is smallest)
	    start-key-vec (vec (concat components (repeat (- 3 (count components)) nil)))
	    start-key (case index
			:eavt (->Datom (nth start-key-vec 0) (nth start-key-vec 1) (nth start-key-vec 2) Long/MAX_VALUE true)
			:aevt (->Datom nil (nth start-key-vec 0) (nth start-key-vec 1) Long/MAX_VALUE true) ; e, v are effectively nil here
			:avet (->Datom nil (nth start-key-vec 0) (nth start-key-vec 1) Long/MAX_VALUE true)) ; e is nil
	    ;; Get subseq starting from the lower bound
	    sub (subseq index-set >= start-key)]
	;; Filter the subseq to keep only exact matches for the provided components
	(lazy-seq
	 (when-let [s (seq sub)]
	   (let [^Datom first-datom (first s)]
	     (if (every? true? (map-indexed
				(fn [idx comp]
				  (or (nil? comp) ;; Treat nil component as wildcard
				      (= comp (case index
						:eavt (case idx 0 (.e first-datom) 1 (.a first-datom) 2 (.v first-datom))
						:aevt (case idx 0 (.a first-datom) 1 (.e first-datom) 2 (.v first-datom))
						:avet (case idx 0 (.a first-datom) 1 (.v first-datom) 2 (.e first-datom))))))
				components))
	       (cons first-datom (datoms-internal db index components (rest s))) ; Recursive call on rest needed if subseq isn't perfect
	       nil)))))))) ; Mismatch, end sequence for this prefix

(defn datoms
  "Index lookup. Returns a lazy sequence of datoms matching components.
   Components are applied according to the index:
   :eavt [e a v]
   :aevt [a e v]
   :avet [a v e]"
  ([db index] (datoms-internal db index))
  ([db index c1] (datoms-internal db index c1))
  ([db index c1 c2] (datoms-internal db index c1 c2))
  ([db index c1 c2 c3] (datoms-internal db index c1 c2 c3)))


(defn- resolve-lookup-ref [db lookup-ref]
  "Resolves a lookup ref [unique-attr value] to an entity ID."
  (when (vector? lookup-ref)
    (let [[a v] lookup-ref]
      ;; Note: Assumes AVET index exists for the unique attribute 'a'
      ;; Real Datascript/Datomic might require :db/unique true in schema
      (:e (first (datoms db :avet a v)))))))

(defn- resolve-eid [db tempids-atom max-eid-atom eid-or-ref]
  "Resolves entity identifiers, handling tempids and lookup refs."
  (cond
    (vector? eid-or-ref) (or (resolve-lookup-ref db eid-or-ref)
			     (throw (ex-info "Lookup ref not found" {:ref eid-or-ref})))
    (and (integer? eid-or-ref) (neg? eid-or-ref)) (resolve-tempid tempids-atom max-eid-atom eid-or-ref)
    :else eid-or-ref))

(defn- apply-tx-op [db schema tx current-tx-id datoms-to-add datoms-to-retract [op e a v :as tx-item]]
  "Processes a single transaction operation, updating datom lists."
  (let [resolved-e e ; EID resolution happens before calling this
	datom (->Datom resolved-e a v tx (= op :db/add))]
    (if (= op :db/add)
      (let [cardinality (get-in schema [a :db/cardinality])]
	(if (= cardinality :db.cardinality/one)
	  ;; Cardinality one: retract existing value first
	  (if-let [existing (first (datoms db :eavt resolved-e a))]
	    (when (not= (.v existing) v) ; Only retract if value is different
	      (swap! datoms-to-retract conj (assoc existing :tx tx :added false))
	      (swap! datoms-to-add conj datom))
	    (swap! datoms-to-add conj datom)) ; No existing value, just add
	  ;; Cardinality many: just add
	  (swap! datoms-to-add conj datom)))
      ;; Retract operation
      (when-let [existing (first (datoms db :eavt resolved-e a v))] ; Find the exact datom to retract
	 (swap! datoms-to-retract conj (assoc existing :tx tx :added false))))))

(defn- normalize-tx-data [tx-data]
  "Converts map-form transactions to list-form."
  (reduce
   (fn [acc item]
     (if (map? item)
       (let [eid (:db/id item)]
	 (into acc (map (fn [[a v]][:db/add eid a v]) (dissoc item :db/id))))
       (conj acc item)))

   tx-data))

(defn transact
  "Applies transaction data to a db value, returning a TxReport.
   Handles tempids, lookup refs, and cardinality."

  (let]
				 (try
				   [op (resolve-eid db-before tempids current-max-eid eid-or-ref) a v]
				   (catch Exception e
				     (throw (ex-info "Failed to resolve EID in transaction item"
						     {:item item :error (.getMessage e)} e)))))
			       normalized-tx-data)
	;; Atoms to collect datoms generated during the transaction
	datoms-to-add (atom)
	datoms-to-retract (atom)]

    ;; Process resolved transaction data to generate datoms
    (doseq [tx-item resolved-tx-data]
      (apply-tx-op db-before schema next-tx datoms-to-add datoms-to-retract tx-item))

    ;; Apply the generated datoms to create the new DB state
    (let
	  (reduce (fn [[eavt aevt avet] ^Datom retracted-datom]
		    ;; Find the *added* datom with same EAV to remove
		    (let [e (.e retracted-datom) a (.a retracted-datom) v (.v retracted-datom)
			  ;; Find the most recent *added* datom matching EAV
			  datom-to-remove (first (filter #(and (= (.e %) e) (= (.a %) a) (= (.v %) v) (.added %))
							 (datoms db-before :eavt e a v)))] ; Use db-before to find what to remove
		      (if datom-to-remove
			[(disj eavt datom-to-remove)
			 (disj aevt datom-to-remove)
			 (disj avet datom-to-remove)]
			[eavt aevt avet]))) ; Datom not found (already retracted?), no change
		  [eavt-after aevt-after avet-after]
		  final-datoms-retracted)
	  ;; Apply additions
	  [eavt-after aevt-after avet-after]
	  (reduce (fn [[eavt aevt avet] ^Datom added-datom]
		    [(conj eavt added-datom)
		     (conj aevt added-datom)
		     (conj avet added-datom)])
		  [eavt-after aevt-after avet-after]
		  final-datoms-added)

	  db-after (map->DB {:schema schema
			     :eavt   eavt-after
			     :aevt   aevt-after
			     :avet   avet-after
			     :max-tx next-tx
			     :max-eid @current-max-eid})]
      ;; Return the transaction report
      (map->TxReport {:db-before db-before
		      :db-after db-after
		      :tx-data (vec (concat final-datoms-added final-datoms-retracted))
		      :tempids @tempids}))))

;; --- Connection Atom ---
(defn create-conn
  "Creates a connection (atom) with an empty DB, optionally with schema."
  ( (atom (empty-db)))
  ([schema] (atom (empty-db schema))))

(defn transact!
  "Applies transaction data to the connection atom, updating it in place.
   Returns the TxReport."
  [conn tx-data]
  (let [report (transact @conn tx-data)]
    (reset! conn (:db-after report))
    report))

;; --- Entity API Sketch ---
(defprotocol IEntity
  (-db [this])
  (-eid [this]))

(deftype Entity [db eid attr-cache]
  clojure.lang.ILookup
  (valAt [this key] (.valAt this key nil))
  (valAt [this key not-found]
    (if (= key :db/id)
      eid
      (if-let [cached (find @attr-cache key)]
	(val cached) ; Return cached value if found
	(let
	  (if-not (seq datoms-seq)
	    (do (swap! attr-cache assoc key not-found) not-found) ; Cache miss
	    (let [result (if (= cardinality :db.cardinality/many)
			   ;; Cardinality many: return set of values
			   (let [vals (set (map :v datoms-seq))]
			     (if (= value-type :db.type/ref)
			       (set (map #(Entity. db % (atom {})) vals)) ; Return set of Entity objects
			       vals))
			   ;; Cardinality one: return single value
			   (let [v (:v (first datoms-seq))] ; Get value from the latest datom
			     (if (= value-type :db.type/ref)
			       (Entity. db v (atom {})) ; Return Entity object
			       v)))]
	      (swap! attr-cache assoc key result) ; Cache result
	      result))))))

  clojure.lang.IMeta
  (meta [this] {:db db :eid eid})

  IEntity
  (-db [this] db)
  (-eid [this] eid)

  ;; Basic print implementation
  Object
  (toString [this] (str "#Entity{" :db/id " " eid "...}")))

(defn entity
  "Retrieves an entity map-like structure by its ID or lookup ref."
  [db eid-or-ref]
  (let [eid (if (vector? eid-or-ref)
	      (resolve-lookup-ref db eid-or-ref)
	      eid-or-ref)]
    (when (and eid (pos-int? eid)) ; Ensure we have a valid positive EID
      (->Entity db eid (atom {})))))


;; --- Basic Datalog Query Sketch ---
;; This is a *very* simplified query engine. Real engines are much more complex.
(defn- join-relations [rel1 rel2]
  (let [common-vars (set/intersection (set (keys (:vars rel1))) (set (keys (:vars rel2))))]
    (if (empty? common-vars)
      ;; Cartesian product (inefficient, avoid if possible in real engine)
      {:vars (merge (:vars rel1) (:vars rel2))
       :tuples (set (for [t1 (:tuples rel1) t2 (:tuples rel2)] (merge t1 t2)))}
      ;; Hash join
      (let
			     (let [join-key (select-keys t2 common-vars)]
			       (if-let [matching-t1s (get indexed-rel1 join-key)]
				 (into acc (map #(merge % t2) matching-t1s))
				 acc)))
			   #{}
			   (:tuples rel2))]
	{:vars (merge (:vars rel1) (:vars rel2))
	 :tuples joined-tuples}))))

(defn- process-where-clause [db current-relation clause]
  ;; Very basic: only handles simple data patterns [?e :attr?v] or [?e :attr literal] etc.
  ;; Needs proper variable binding, index selection based on bound vars, etc.
  (if (vector? clause)
    (let [[e a v] clause
	  ;; Determine bound vars based on current-relation (simplified)
	  bound-vars (set (keys (:vars current-relation)))
	  ;; Generate datoms based on clause pattern and bound vars (highly simplified)
	  ;; Real engine needs sophisticated index selection and variable unification
	  pattern-datoms (cond
			   (and (symbol? e) (not (bound-vars e)) (keyword? a) (symbol? v) (not (bound-vars v)))
			   (datoms db :aevt a) ; Find all e, v for a given a
			   (and (symbol? e) (bound-vars e) (keyword? a) (symbol? v) (not (bound-vars v)))
			   (mapcat #(datoms db :eavt % a) (map e (:tuples current-relation))) ; Find v for known e, a
			   ;;... many more cases needed...
			   :else) ; Fallback: empty for unhandled patterns
	  ;; Convert datoms to a relation (simplified)
	  new-relation {:vars (zipmap (filter symbol? [e a v]) (range)) ; Map vars to tuple index
			:tuples (set (map (fn [^Datom d]
					   (let [vals {:e (.e d) :a (.a d) :v (.v d)}]
					     ;; Create tuple based on which elements are vars
					     (->> [e a v]
						  (map #(if (symbol? %) (get vals (keyword (name %))) %))
						  (zipmap (filter symbol? [e a v])))))
					 pattern-datoms))}]
      (join-relations current-relation new-relation))
    current-relation)) ; Ignore non-vector clauses for now

(defn q
  "Basic Datalog query. Handles simple :find, :where, :in. No rules, aggregates etc."
  [query db & inputs]
  (let
    (set results))) ; Return a set of result maps


;; --- Basic Pull API Sketch ---
(defn- pull* [entity pattern]
  (cond
    (= pattern '*) (into {} entity) ; Basic wildcard (needs proper attribute fetching)
    (vector? pattern) (select-keys (into {} entity) pattern) ; Select specific keys
    ;; Add more pattern handling (nested maps, defaults, etc.) later
    :else {}))

(defn pull
  "Basic Pull API implementation."
  [db pattern eid-or-ref]
  (when-let [ent (entity db eid-or-ref)]
    (pull* ent pattern)))

(defn pull-many
  "Basic Pull API for multiple entities."
  [db pattern eids-or-refs]
  (vec (keep #(pull db pattern %) eids-or-refs)))


;; --- Example Usage ---
(comment
  ;; Create a connection with schema
  (def conn (create-conn {:name {:db/cardinality :db.cardinality/one}
			  :likes {:db/cardinality :db.cardinality/many}
			  :friend {:db/cardinality :db.cardinality/one
				   :db/valueType :db.type/ref}
			  :email {:db/unique :db.unique/identity}}))

  ;; Transact initial data using tempids
  (def report1 (transact! conn [{:db/id -1 :name "Alice" :likes ["pizza" "fries"] :email "alice@example.com"}
				 {:db/id -2 :name "Bob" :likes ["sushi"]}]))
  (def alice-id (get (:tempids report1) -1))
  (def bob-id (get (:tempids report1) -2))
  (println "Alice:" alice-id "Bob:" bob-id)

  ;; Add a relationship
  (transact! conn [[:db/add alice-id :friend bob-id]])

  ;; Query using datoms
  (println "Alice's likes:" (map :v (datoms @conn :eavt alice-id :likes)))
  ; => ("fries" "pizza")

  ;; Query using basic 'q'
  (println "People who like pizza:"
	   (q '[:find?name
		:where [?p :name?name]
		       [?p :likes "pizza"]]
	      @conn))
  ; => #{{?name "Alice"}}

  ;; Query using basic 'q' with join
  (println "Friends of Alice:"
	   (q '[:find?friend-name
		:where [?alice :name "Alice"]
		       [?alice :friend?friend-eid]
		       [?friend-eid :name?friend-name]]
	      @conn))
  ; => #{{?friend-name "Bob"}}

  ;; Use entity API
  (def alice (entity @conn alice-id))
  (println "Alice's name:" (:name alice)) ; => "Alice"
  (println "Alice's likes:" (:likes alice)) ; => #{"pizza" "fries"}
  (println "Alice's friend's name:" (:name (:friend alice))) ; => "Bob"

  ;; Use Pull API
  (println "Pull Alice:" (pull @conn [:name :likes] alice-id))
  ; => {:name "Alice", :likes #{"pizza" "fries"}}
  (println "Pull Alice with friend:" (pull @conn [:name {:friend [:name]}] alice-id))
  ; => {:name "Alice", :friend {:name "Bob"}}
  (println "Pull Many:" (pull-many @conn [:name][alice-id bob-id]))
  ; =>

  ;; Update Alice's name (cardinality one)
  (def report-update (transact! conn]))
  (println "Update tx-data:" (:tx-data report-update))
  ; Should show retraction of "Alice" and addition of "Alice Smith"
  (println "New name:" (:name (entity @conn alice-id))) ; => "Alice Smith"

  ;; Retract one of Alice's likes (cardinality many)
  (transact! conn [[:db/retract alice-id :likes "fries"]])
  (println "Alice's likes now:" (:likes (entity @conn alice-id))) ; => #{"pizza"}

)