Coverage report: /development/source/library/org/datagraph/spocq-shard/src/algebra/matrix-operators/predicates.lisp

KindCoveredAll%
expression0159 0.0
branch06 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
 
5
 (:documentation "sparql filter operation generation for matrix fields")
6
 
7
 ;;; (load (compile-file "/development/source/library/org/datagraph/spocq/src/algebra/matrix-operators/predicates.lisp"))
8
 
9
 
10
 (defun matrix-unary-predicate-operator (base-dimensions test)
11
   (let* ((abstracted-dimensions (loop for dimension in base-dimensions
12
                                       for position from 0
13
                                       collect (when dimension (cons-symbol *variable-package* :var (prin1-to-string position)))))
14
          (abstracted-test (sublis (loop for dimension in base-dimensions
15
                                         for abstracted in abstracted-dimensions
16
                                         when dimension
17
                                         collect (cons dimension abstracted))
18
                                   test)))
19
     (ensure-matrix-operator 'unary-predicate :dimensions abstracted-dimensions :test abstracted-test)))
20
 
21
 (defun matrix-binary-predicate-operator (left-dimensions right-dimensions test)
22
   (let* ((abstracted-left-dimensions (loop for dimension in left-dimensions
23
                                       for position from 0
24
                                       collect (cons-symbol *variable-package* :var (prin1-to-string position))))
25
          (abstracted-right-dimensions (loop for dimension in right-dimensions
26
                                       for position from (length left-dimensions)
27
                                       collect (cons-symbol *variable-package* :var (prin1-to-string position))))
28
          (abstracted-test (sublis (loop for dimension in (append left-dimensions right-dimensions)
29
                                         for abstracted in (append abstracted-left-dimensions abstracted-right-dimensions)
30
                                         when dimension
31
                                         collect (cons dimension abstracted))
32
                                   test)))
33
     (ensure-matrix-operator 'binary-predicate :left-dimensions abstracted-left-dimensions :right-dimensions abstracted-right-dimensions :test abstracted-test)))
34
 
35
 
36
 (defmethod compute-matrix-operator-lambda ((operator (eql 'unary-predicate)) &key dimensions test)
37
   (let* ((source-column-count (length dimensions))
38
          (test-variables (expression-dimensions test))
39
          (reference-count 0)
40
          (undefined-variables ())
41
          (macros (loop for variable in test-variables
42
                        for position = (position variable dimensions)
43
                        collect `(,variable ,(cond (position
44
                                                    (incf reference-count)
45
                                                    `(foreign-array-named-object-ref ,variable %source-data source-row ,position))
46
                                                   (t
47
                                                    (push variable undefined-variables)
48
                                                    `(query-binding-value ',variable))))))
49
          (lambda `(lambda (%source-data source-row)
50
                     (declare (foreign-type (foreign-array ,+matrix-element-type+ (* ,source-column-count)) %source-data)
51
                              (type sb-sys:system-area-pointer %source-data)
52
                              (type fixnum source-row)
53
                              (optimize ,@*field-optimization*)
54
                              ,@(unless (plusp reference-count) '((ignorable %source-data source-row))))
55
                     (symbol-macrolet ,macros
56
                       (ebv ,test)))))
57
     (when undefined-variables
58
       (case (undefined-variable-behavior)
59
         (|urn:dydra|:|error| (spocq.e:compilation-error :expression test
60
                                                 :condition (make-condition 'spocq.e:undefined-variable-error
61
                                                                            :variables undefined-variables)))
62
         (|urn:dydra|:|warning| (log-warn "~@[~a: ~]~a"
63
                                          *query*
64
                                          (make-condition 'spocq.e:undefined-variable-error
65
                                                          :expression test
66
                                                          :variables undefined-variables))
67
                                (push `(declare (special ,@undefined-variables)) (cddr lambda)))
68
         (|urn:dydra|:|dynamicBinding| (push `(declare (special ,@undefined-variables)) (cddr lambda)))))
69
     lambda))
70
 
71
 ;;; (spocq-compile (compute-matrix-operator-lambda 'unary-predicate :dimensions '(?::var1 ?::var2) :test '(= ?::var1 ?::var2)))
72
 
73
 
74
 (defmethod compute-matrix-operator-lambda ((operator (eql 'binary-predicate)) &key left-dimensions right-dimensions test)
75
   (let* ((left-column-count (length left-dimensions))
76
          (right-column-count (length right-dimensions))
77
          (test-variables (expression-dimensions test))
78
          (left-reference-count 0)
79
          (right-reference-count 0)
80
          (undefined-variables ())
81
          (macros (loop for variable in test-variables
82
                        for left-position = (position variable left-dimensions)
83
                        for right-position = (position variable right-dimensions)
84
                        collect `(,variable ,(cond (left-position
85
                                                    (incf left-reference-count)
86
                                                    `(foreign-array-named-object-ref ,variable %left-data left-row ,left-position))
87
                                                   (right-position
88
                                                    (incf right-reference-count)
89
                                                    `(foreign-array-named-object-ref ,variable %right-data right-row ,right-position))
90
                                                   (t
91
                                                    (push variable undefined-variables)
92
                                                    `(query-binding-value ',variable))))))
93
          (lambda `(lambda (%left-data left-row %right-data right-row)
94
                     (declare (foreign-type (foreign-array ,+matrix-element-type+ (* ,left-column-count)) %left-data)
95
                              (foreign-type (foreign-array ,+matrix-element-type+ (* ,right-column-count)) %right-data)
96
                              (type sb-sys:system-area-pointer %left-data %right-data)
97
                              (type fixnum left-row right-row)
98
                              (optimize ,@*field-optimization*)
99
                              ,@(unless (plusp left-reference-count) '((ignorable %left-data left-row)))
100
                              ,@(unless (plusp right-reference-count) '((ignorable %right-data right-row))))
101
                     (symbol-macrolet ,macros
102
                       (ebv ,test)))))
103
     (when undefined-variables
104
       (case (undefined-variable-behavior)
105
         (|urn:dydra|:|error| (spocq.e:compilation-error :expression test
106
                                                 :condition (make-condition 'spocq.e:undefined-variable-error
107
                                                                            :variables undefined-variables)))
108
         (|urn:dydra|:|warning| (log-warn "~@[~a: ~]~a"
109
                                          *query*
110
                                          (make-condition 'spocq.e:undefined-variable-error
111
                                                          :expression test
112
                                                          :variables undefined-variables))
113
                                (push `(declare (special ,@undefined-variables)) (cddr lambda)))
114
         (|urn:dydra|:|dynamicBinding| (push `(declare (special ,@undefined-variables)) (cddr lambda)))))
115
     lambda))