Coverage report: /development/source/library/org/datagraph/spocq-shard/src/store/rdfcache/geolocation-index.lisp

KindCoveredAll%
expression062 0.0
branch04 0.0
Key
Not instrumented
Conditionalized out
Executed
Not executed
 
Both branches taken
One branch taken
Neither branch taken
1
 ;;; -*- Mode: lisp; Syntax: ansi-common-lisp; Base: 10; Package: org.datagraph.spocq.implementation; -*-
2
 
3
 (in-package :org.datagraph.spocq.implementation)
4
 ;; (load "/development/source/library/org/datagraph/spocq/src/store/geolocation-index.lisp")
5
 
6
 
7
 
8
 
9
 (defmethod compute-index-statements ((index (eql '|geo|:|lat|)) statements filters)
10
 
11
   (compute-geocoordinate-index index statements filters))
12
 
13
 
14
 (defmethod compute-index-statements ((index (eql '|geo|:|long|)) statements filters)
15
   "The statements should comprise one each for each variable combination and
16
  at least one filter clause per object variable. correlate these to construct
17
  one bgp:index-match for each (subject object min max combination).
18
 
19
  The only predicates should match the index name."
20
 
21
   (compute-geocoordinate-index index statements filters))
22
 
23
 
24
 (defun compute-geocoordinate-index (index statements filters)
25
   (loop for statement in statements
26
         with graph = nil
27
         collect (let ((predicate (statement-predicate statement))
28
                       (object (statement-object statement)))
29
                   (assert (equalp predicate index) ()
30
                           "invalid index pattern: variant predicate: ~s." statement)
31
                   (if graph
32
                     (assert (equalp graph (statement-context statement)) ()
33
                             "Invalid index pattern; spans graphs: ~s." statements)
34
                     (setf graph (statement-context statement)))
35
                   (loop with statement-filters = ()
36
                         for filter in filters
37
                         for filter-variables = (expression-variables filter)
38
                         when (find object filter-variables)
39
                         do (pushnew filter statement-filters)
40
                    finally (return (append statement
41
                                            `(:test ,(reduce #'(lambda (e1 &optional e2)
42
                                                                 (if e2 `(spocq.a:&& ,e1 ,e2) e1))
43
                                                             statement-filters
44
                                                             :key #'(lambda (expression)
45
                                                                      (destructuring-bind (operator arg1 arg2) (second expression)
46
                                                                        (if (variable-p arg1)
47
                                                                          (list operator arg2)
48
                                                                          (list (ecase operator
49
                                                                                  (spocq.a:< 'spocq.a:>)
50
                                                                                  (spocq.a:> 'spocq.a:<)
51
                                                                                  (spocq.a:<= 'spocq.a:>=)
52
                                                                                  (spocq.a:>= 'spocq.a:<=))
53
                                                                                arg1)))))
54
                                               :index ,index)))))))